diff --git a/src/main/java/ch/njol/skript/classes/data/DefaultComparators.java b/src/main/java/ch/njol/skript/classes/data/DefaultComparators.java
index fee9c1ebce9..1fa65336b20 100644
--- a/src/main/java/ch/njol/skript/classes/data/DefaultComparators.java
+++ b/src/main/java/ch/njol/skript/classes/data/DefaultComparators.java
@@ -445,19 +445,6 @@ public boolean supportsOrdering() {
 			}
 		});
 		
-		// StructureType - StructureType
-		Comparators.registerComparator(StructureType.class, StructureType.class, new Comparator<StructureType, StructureType>() {
-			@Override
-			public Relation compare(StructureType s1, StructureType s2) {
-				return Relation.get(CollectionUtils.containsAll(s2.getTypes(), s2.getTypes()));
-			}
-
-			@Override
-			public boolean supportsOrdering() {
-				return false;
-			}
-		});
-		
 		// Object - ClassInfo
 		Comparators.registerComparator(Object.class, ClassInfo.class, new Comparator<Object, ClassInfo>() {
 			@Override
diff --git a/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java b/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
index 64d87876962..4fd2d2de791 100644
--- a/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
+++ b/src/main/java/ch/njol/skript/classes/data/SkriptClasses.java
@@ -374,32 +374,13 @@ public String toVariableNameString(Color color) {
 					}
 				}));
 
-		Classes.registerClass(new ClassInfo<>(StructureType.class, "structuretype")
+		Classes.registerClass(new EnumClassInfo<>(TreeSpecies.class, "treetype", "tree types")
 				.user("tree ?types?", "trees?")
 				.name("Tree Type")
 				.description("A tree type represents a tree species or a huge mushroom species. These can be generated in a world with the <a href='#EffTree'>generate tree</a> effect.")
-				.usage("[any] <general tree/mushroom type>, e.g. tree/any jungle tree/etc.", "<specific tree/mushroom species>, e.g. red mushroom/small jungle tree/big regular tree/etc.")
 				.examples("grow any regular tree at the block",
 						"grow a huge red mushroom above the block")
-				.since("")
-				.defaultExpression(new SimpleLiteral<>(StructureType.TREE, true))
-				.parser(new Parser<StructureType>() {
-					@Override
-					@Nullable
-					public StructureType parse(final String s, final ParseContext context) {
-						return StructureType.fromName(s);
-					}
-
-					@Override
-					public String toString(final StructureType o, final int flags) {
-						return o.toString(flags);
-					}
-
-					@Override
-					public String toVariableNameString(final StructureType o) {
-						return "" + o.name().toLowerCase(Locale.ENGLISH);
-					}
-				}).serializer(new EnumSerializer<>(StructureType.class)));
+				.since("1.0"));
 
 		Classes.registerClass(new ClassInfo<>(EnchantmentType.class, "enchantmenttype")
 				.user("enchant(ing|ment) types?")
diff --git a/src/main/java/ch/njol/skript/effects/EffTree.java b/src/main/java/ch/njol/skript/effects/EffTree.java
index 71f141eeff4..8b020454865 100644
--- a/src/main/java/ch/njol/skript/effects/EffTree.java
+++ b/src/main/java/ch/njol/skript/effects/EffTree.java
@@ -13,7 +13,7 @@
 import ch.njol.skript.lang.Expression;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
 import ch.njol.skript.util.Direction;
-import ch.njol.skript.util.StructureType;
+import ch.njol.skript.util.TreeSpecies;
 import ch.njol.util.Kleenean;
 
 /**
@@ -28,26 +28,26 @@ public class EffTree extends Effect {
 	
 	static {
 		Skript.registerEffect(EffTree.class,
-				"(grow|create|generate) tree [of type %structuretype%] %directions% %locations%",
-				"(grow|create|generate) %structuretype% %directions% %locations%");
+				"(grow|create|generate) tree [of type %treetype%] %directions% %locations%",
+				"(grow|create|generate) %treetype% %directions% %locations%");
 	}
 	
 	@SuppressWarnings("null")
 	private Expression<Location> blocks;
 	@SuppressWarnings("null")
-	private Expression<StructureType> type;
+	private Expression<TreeSpecies> type;
 	
 	@SuppressWarnings({"unchecked", "null"})
 	@Override
 	public boolean init(final Expression<?>[] exprs, final int matchedPattern, final Kleenean isDelayed, final ParseResult parser) {
-		type = (Expression<StructureType>) exprs[0];
+		type = (Expression<TreeSpecies>) exprs[0];
 		blocks = Direction.combine((Expression<? extends Direction>) exprs[1], (Expression<? extends Location>) exprs[2]);
 		return true;
 	}
 	
 	@Override
 	public void execute(final Event e) {
-		final StructureType type = this.type.getSingle(e);
+		final TreeSpecies type = this.type.getSingle(e);
 		if (type == null)
 			return;
 		for (final Location l : blocks.getArray(e)) {
diff --git a/src/main/java/ch/njol/skript/events/EvtGrow.java b/src/main/java/ch/njol/skript/events/EvtGrow.java
index f5bdc5a6629..0a33e732408 100644
--- a/src/main/java/ch/njol/skript/events/EvtGrow.java
+++ b/src/main/java/ch/njol/skript/events/EvtGrow.java
@@ -7,7 +7,7 @@
 import ch.njol.skript.lang.LiteralList;
 import ch.njol.skript.lang.SkriptEvent;
 import ch.njol.skript.lang.SkriptParser.ParseResult;
-import ch.njol.skript.util.StructureType;
+import ch.njol.skript.util.TreeSpecies;
 import ch.njol.util.coll.CollectionUtils;
 import org.bukkit.Material;
 import org.bukkit.TreeType;
@@ -32,10 +32,10 @@ public class EvtGrow extends SkriptEvent {
 	
 	static {
 		Skript.registerEvent("Grow", EvtGrow.class, CollectionUtils.array(StructureGrowEvent.class, BlockGrowEvent.class),
-				"grow[th] [of (1:%-structuretypes%|2:%-itemtypes/blockdatas%)]",
+				"grow[th] [of (1:%-treetypes%|2:%-itemtypes/blockdatas%)]",
 				"grow[th] from %itemtypes/blockdatas%",
-				"grow[th] [in]to (1:%structuretypes%|2:%itemtypes/blockdatas%)",
-				"grow[th] from %itemtypes/blockdatas% [in]to (1:%structuretypes%|2:%itemtypes/blockdatas%)"
+				"grow[th] [in]to (1:%treetypes%|2:%itemtypes/blockdatas%)",
+				"grow[th] from %itemtypes/blockdatas% [in]to (1:%treetypes%|2:%itemtypes/blockdatas%)"
 				)
 				.description(
 					"Called when a tree, giant mushroom or plant grows to next stage.",
@@ -174,8 +174,8 @@ private static boolean checkTo(Event event, Literal<Object> types) {
 		if (event instanceof StructureGrowEvent) {
 			TreeType species = ((StructureGrowEvent) event).getSpecies();
 			return types.check(event, type -> {
-				if (type instanceof StructureType) {
-					return ((StructureType) type).is(species);
+				if (type instanceof TreeSpecies) {
+					return ((TreeSpecies) type).is(species);
 				}
 				return false;
 			});
diff --git a/src/main/java/ch/njol/skript/util/StructureType.java b/src/main/java/ch/njol/skript/util/StructureType.java
deleted file mode 100644
index f15182c7892..00000000000
--- a/src/main/java/ch/njol/skript/util/StructureType.java
+++ /dev/null
@@ -1,103 +0,0 @@
-package ch.njol.skript.util;
-
-import java.util.HashMap;
-import java.util.Locale;
-import java.util.Map;
-import java.util.Map.Entry;
-import java.util.regex.Pattern;
-
-import org.bukkit.Location;
-import org.bukkit.TreeType;
-import org.bukkit.block.Block;
-import org.jetbrains.annotations.Nullable;
-
-import ch.njol.skript.localization.Language;
-import ch.njol.skript.localization.Noun;
-import ch.njol.util.coll.CollectionUtils;
-
-public enum StructureType {
-	TREE(TreeType.TREE, TreeType.BIG_TREE, TreeType.REDWOOD, TreeType.TALL_REDWOOD, TreeType.MEGA_REDWOOD,
-			TreeType.BIRCH, TreeType.TALL_BIRCH, TreeType.SMALL_JUNGLE, TreeType.JUNGLE, TreeType.COCOA_TREE,
-			TreeType.ACACIA, TreeType.DARK_OAK, TreeType.SWAMP),
-	
-	REGULAR(TreeType.TREE, TreeType.BIG_TREE), SMALL_REGULAR(TreeType.TREE), BIG_REGULAR(TreeType.BIG_TREE),
-	REDWOOD(TreeType.REDWOOD, TreeType.TALL_REDWOOD), SMALL_REDWOOD(TreeType.REDWOOD), BIG_REDWOOD(TreeType.TALL_REDWOOD),
-	MEGA_REDWOOD(TreeType.MEGA_REDWOOD),
-	BIRCH(TreeType.BIRCH), TALL_BIRCH(TreeType.TALL_BIRCH),
-	JUNGLE(TreeType.SMALL_JUNGLE, TreeType.JUNGLE), SMALL_JUNGLE(TreeType.SMALL_JUNGLE), BIG_JUNGLE(TreeType.JUNGLE),
-	JUNGLE_BUSH(TreeType.JUNGLE_BUSH), COCOA_TREE(TreeType.COCOA_TREE),
-	ACACIA(TreeType.ACACIA), DARK_OAK(TreeType.DARK_OAK),
-	SWAMP(TreeType.SWAMP),
-	
-	MUSHROOM(TreeType.RED_MUSHROOM, TreeType.BROWN_MUSHROOM),
-	RED_MUSHROOM(TreeType.RED_MUSHROOM), BROWN_MUSHROOM(TreeType.BROWN_MUSHROOM),
-	
-	;
-	
-	private Noun name;
-	private final TreeType[] types;
-	
-	private StructureType(final TreeType... types) {
-		this.types = types;
-		name = new Noun("tree types." + name() + ".name");
-	}
-	
-	public void grow(final Location loc) {
-		TreeType tree = CollectionUtils.getRandom(types);
-		assert tree != null; // No enum member causes empty types
-		loc.getWorld().generateTree(loc, tree);
-	}
-	
-	public void grow(final Block b) {
-		TreeType tree = CollectionUtils.getRandom(types);
-		assert tree != null; // No enum member causes empty types
-		b.getWorld().generateTree(b.getLocation(), tree);
-	}
-	
-	public TreeType[] getTypes() {
-		return types;
-	}
-	
-	@Override
-	public String toString() {
-		return name.toString();
-	}
-	
-	public String toString(final int flags) {
-		return name.toString(flags);
-	}
-	
-	public Noun getName() {
-		return name;
-	}
-	
-	public boolean is(final TreeType type) {
-		return CollectionUtils.contains(types, type);
-	}
-	
-	/**
-	 * lazy
-	 */
-	final static Map<Pattern, StructureType> parseMap = new HashMap<>();
-	
-	static {
-		Language.addListener(parseMap::clear);
-	}
-	
-	@Nullable
-	public static StructureType fromName(String s) {
-		if (parseMap.isEmpty()) {
-			for (final StructureType t : values()) {
-				final String pattern = Language.get("tree types." + t.name() + ".pattern");
-				parseMap.put(Pattern.compile(pattern, Pattern.CASE_INSENSITIVE), t);
-			}
-		}
-		s = "" + s.toLowerCase(Locale.ENGLISH);
-		for (final Entry<Pattern, StructureType> e : parseMap.entrySet()) {
-			if (e.getKey().matcher(s).matches())
-				return e.getValue();
-		}
-		return null;
-	}
-	
-}
diff --git a/src/main/java/ch/njol/skript/util/TreeSpecies.java b/src/main/java/ch/njol/skript/util/TreeSpecies.java
new file mode 100644
index 00000000000..12e7707aa8d
--- /dev/null
+++ b/src/main/java/ch/njol/skript/util/TreeSpecies.java
@@ -0,0 +1,116 @@
+package ch.njol.skript.util;
+
+import ch.njol.util.coll.CollectionUtils;
+import org.bukkit.Location;
+import org.bukkit.TreeType;
+import org.bukkit.World;
+import org.bukkit.block.Block;
+
+/**
+ * Repesents a grouping of Bukkkit {@link TreeType TreeTypes}
+ */
+public enum TreeSpecies {
+	TREE(TreeType.values()),
+
+	OAK(TreeType.TREE, TreeType.BIG_TREE),
+	SMALL_OAK(TreeType.TREE),
+	BIG_OAK(TreeType.BIG_TREE),
+
+	SPRUCE(TreeType.REDWOOD, TreeType.TALL_REDWOOD),
+	SMALL_SPRUCE(TreeType.REDWOOD),
+	BIG_SPRUCE(TreeType.TALL_REDWOOD),
+	MEGA_SPRUCE(TreeType.MEGA_REDWOOD),
+
+	BIRCH(TreeType.BIRCH, TreeType.TALL_BIRCH),
+	SMALL_BIRCH(TreeType.BIRCH),
+	TALL_BIRCH(TreeType.TALL_BIRCH),
+
+	JUNGLE(TreeType.SMALL_JUNGLE, TreeType.JUNGLE, TreeType.COCOA_TREE),
+	SMALL_JUNGLE(TreeType.SMALL_JUNGLE),
+	BIG_JUNGLE(TreeType.JUNGLE),
+	COCOA_TREE(TreeType.COCOA_TREE),
+
+	JUNGLE_BUSH(TreeType.JUNGLE_BUSH),
+
+	ACACIA(TreeType.ACACIA),
+	DARK_OAK(TreeType.DARK_OAK),
+	SWAMP(TreeType.SWAMP),
+
+	MUSHROOM(TreeType.RED_MUSHROOM, TreeType.BROWN_MUSHROOM),
+	RED_MUSHROOM(TreeType.RED_MUSHROOM),
+	BROWN_MUSHROOM(TreeType.BROWN_MUSHROOM),
+
+	MANGROVE(TreeType.MANGROVE, TreeType.TALL_MANGROVE),
+	SMALL_MANGROVE(TreeType.MANGROVE),
+	BIG_MANGROVE(TreeType.TALL_MANGROVE),
+
+	AZALEA(TreeType.AZALEA),
+
+	PALE_OAK(TreeType.PALE_OAK, TreeType.PALE_OAK_CREAKING),
+	PALE_OAK_NORMAL(TreeType.PALE_OAK),
+	PALE_OAK_CREAKING(TreeType.PALE_OAK_CREAKING),
+
+	CHERRY(TreeType.CHERRY),
+
+	CRIMSON_FUNGUS(TreeType.CRIMSON_FUNGUS),
+	WARPED_FUNGUS(TreeType.WARPED_FUNGUS),
+
+	CHORUS_PLANT(TreeType.CHORUS_PLANT),
+	;
+
+	private final TreeType[] types;
+
+	TreeSpecies(TreeType... types) {
+		this.types = types;
+	}
+
+	/**
+	 * Grow a tree at a location.
+	 * <p>
+	 * If the species is a group, a random tree type is selected.
+	 * </p>
+	 *
+	 * @param location Location to grow the tree at
+	 */
+	public void grow(Location location) {
+		TreeType tree = CollectionUtils.getRandom(types);
+		assert tree != null; // No enum member causes empty types
+		World world = location.getWorld();
+		if (world == null) {
+			return;
+		}
+		world.generateTree(location, tree);
+	}
+
+	/**
+	 * Grow a tree at a location.
+	 * <p>
+	 * If the species is a group, a random tree type is selected.
+	 * </p>
+	 *
+	 * @param block Block to grow the tree at
+	 */
+	public void grow(Block block) {
+		grow(block.getLocation());
+	}
+
+	/**
+	 * Get the TreeTypes that make up this species.
+	 *
+	 * @return TreeTypes that make up this species
+	 */
+	public TreeType[] getTypes() {
+		return types;
+	}
+
+	/**
+	 * Check if this species contains a specific tree type.
+	 *
+	 * @param type TreeType to check for
+	 * @return True if the species contains the type, false otherwise
+	 */
+	public boolean is(TreeType type) {
+		return CollectionUtils.contains(types, type);
+	}
+
+}
diff --git a/src/main/resources/lang/default.lang b/src/main/resources/lang/default.lang
index 540fa9cfb8f..30f9c65b0c7 100644
--- a/src/main/resources/lang/default.lang
+++ b/src/main/resources/lang/default.lang
@@ -289,69 +289,39 @@ biomes:
 
 # -- Tree Types --
 tree types:
-	tree:
-		name: tree¦s
-		pattern: (any )?trees?
-	regular:
-		name: oak¦s
-		pattern: (any )?(regular|normal|oak)( tree)?s?
-	small_regular:
-		name: small oak¦s
-		pattern: small (regular|normal|oak)( tree)?s?
-	big_regular:
-		name: big tree¦s
-		pattern: (big|large) (regular|normal|oak)( tree)?s?
-	redwood:
-		name: redwood¦s
-		pattern: (any )?(fir|pine|spruce|redwood)( tree)?s?
-	small_redwood:
-		name: small redwood¦s
-		pattern: small (fir|pine|spruce|redwood)( tree)?s?
-	big_redwood:
-		name: tall redwood¦s
-		pattern: (big|tall) (fir|pine|spruce|redwood)( tree)?s?
-	mega_redwood:
-		name: mega redwood¦s
-		pattern: (mega|giant) (fir|pine|spruce|redwood)( tree)?s?
-	birch:
-		name: birch¦es
-		pattern: birch( trees?|es)
-	tall_birch:
-		name: tall birch¦es
-		pattern: (tall|big) birch( trees?|es)
-	jungle:
-		name: jungle tree¦s
-		pattern: (any )?jungle( tree)?s?
-	small_jungle:
-		name: small jungle tree¦s
-		pattern: small jungle( tree)?s?
-	big_jungle:
-		name: big jungle tree¦s
-		pattern: (big|tall|huge|giant|large) jungle( tree)?s?
-	cocoa_tree:
-		name: cocoa tree¦s
-		pattern: cocoa trees?
-	acacia:
-		name: acacia¦s
-		pattern: acacia( tree)?s?
-	dark_oak:
-		name: dark oak¦s
-		pattern: dark oak( tree)?s?
-	jungle_bush:
-		name: bush¦es
-		pattern: (jungle )?bush(es)?
-	swamp:
-		name: swamp tree¦s
-		pattern: swamp trees?
-	mushroom:
-		name: huge mushroom¦s
-		pattern: (any )?(huge|giant|large|big) mushrooms?
-	red_mushroom:
-		name: huge red mushroom¦s
-		pattern: (huge|giant|large|big) red mushrooms?
-	brown_mushroom:
-		name: huge brown mushroom¦s
-		pattern: (huge|giant|large|big) brown mushrooms?
+	tree: tree, any tree
+	oak: oak tree, any oak tree, any normal tree, any regular tree
+	small_oak: small oak tree, small normal tree, small regular tree
+	big_oak: big oak tree, big normal tree, big regular tree
+	spruce: spruce tree, any spruce tree
+	small_spruce: small spruce tree
+	big_spruce: big spruce tree, tall spruce tree
+	mega_spruce: mega spruce tree, giant spruce tree
+	birch: birch tree, any birch tree
+	small_birch: small birch tree
+	tall_birch: tall birch tree
+	jungle: jungle tree, any jungle tree
+	small_jungle: small jungle tree
+	big_jungle: big jungle tree, tall jungle tree, giant jungle tree
+	cocoa_tree: cocoa tree, jungle cocoa tree, cocoa jungle tree
+	jungle_bush: jungle bush, jungle bush tree
+	acacia: acacia tree
+	dark_oak: dark oak tree
+	swamp: swamp tree, swamp oak, swamp oak tree
+	mushroom: huge mushroom, any huge mushroom
+	red_mushroom: huge red mushroom
+	brown_mushroom: huge brown mushroom
+	mangrove: mangrove tree, any mangrove treee
+	small_mangrove: small mangrove tree
+	big_mangrove: big mangrove tree
+	azalea: azalea tree
+	pale_oak: pale oak tree, any pale oak tree
+	pale_oak_normal: normal pale oak tree
+	pale_oak_creaking: creaking pale oak tree
+	cherry: cherry tree
+	crimson_fungus: crimson fungus, crimson tree, crimson fungus tree
+	warped_fungus: warped fungus, warped tree, warped fungus tree
+	chorus_plant: chorus plant
 
 # -- Time --
 time:
@@ -2915,7 +2885,7 @@ types:
 	direction: direction¦s @a
 	slot: slot¦s @a
 	color: color¦s @a
-	structuretype: tree type¦s @a
+	treetype: tree type¦s @a
 	enchantmenttype: enchantment type¦s @an
 	experience: experience point¦s @an
 	experience.pattern: (e?xp|experience( points?)?)
diff --git a/src/test/java/org/skriptlang/skript/test/tests/classes/ClassesTest.java b/src/test/java/org/skriptlang/skript/test/tests/classes/ClassesTest.java
index edda38d818d..0d232e50719 100644
--- a/src/test/java/org/skriptlang/skript/test/tests/classes/ClassesTest.java
+++ b/src/test/java/org/skriptlang/skript/test/tests/classes/ClassesTest.java
@@ -18,7 +18,7 @@
 import ch.njol.skript.util.Direction;
 import ch.njol.skript.util.Experience;
 import ch.njol.skript.util.SkriptColor;
-import ch.njol.skript.util.StructureType;
+import ch.njol.skript.util.TreeSpecies;
 import ch.njol.skript.util.Time;
 import ch.njol.skript.util.Timeperiod;
 import ch.njol.skript.util.Timespan;
@@ -34,7 +34,7 @@ public void serializationTest() {
 				"String",
 				
 				// Skript
-				SkriptColor.BLACK, StructureType.RED_MUSHROOM, WeatherType.THUNDER,
+				SkriptColor.BLACK, TreeSpecies.RED_MUSHROOM, WeatherType.THUNDER,
 				new Date(System.currentTimeMillis()), new Timespan(1337), new Time(12000), new Timeperiod(1000, 23000),
 				new Experience(15), new Direction(0, Math.PI, 10), new Direction(new double[] {0, 1, 0}),
 				new EntityType(new SimpleEntityData(HumanEntity.class), 300),
diff --git a/src/test/skript/tests/syntaxes/effects/EffTree.sk b/src/test/skript/tests/syntaxes/effects/EffTree.sk
new file mode 100644
index 00000000000..a532719737a
--- /dev/null
+++ b/src/test/skript/tests/syntaxes/effects/EffTree.sk
@@ -0,0 +1,36 @@
+function cleanUpTree(loc: location):
+	set {_l1} to {_loc} ~ vector(7,20,7)
+	set {_l2} to {_loc} ~ vector(-7,-1,-7)
+	loop blocks within {_l1} and {_l2}:
+		if any:
+			loop-block is tagged as block tag "minecraft:mineable/axe"
+			loop-block is tagged as block tag "minecraft:leaves"
+			loop-block is creaking heart
+			loop-block is dirt
+		then:
+			set loop-block to air
+
+test "grow a tree":
+	set {_loc} to event-location
+	cleanUpTree({_loc}) # Pre cleanup to make sure we can grow a tree here
+	set block at {_loc} to dirt # Make sure our tree can grow here
+
+	# Attempt to grow an oak tree
+	grow oak tree above {_loc}
+	set {_verify} to block 2 above {_loc}
+	assert {_verify} is oak log with "The oak tree should have grown"
+	cleanUpTree({_loc})
+
+	# Attempt to grow a huge mushroom
+	set block at {_loc} to dirt # Make sure our tree can grow here
+	grow huge mushroom above {_loc}
+	set {_verify} to block 2 above {_loc}
+	assert {_verify} is mushroom stem with "The huge mushroom should have grown"
+	cleanUpTree({_loc})
+
+	# Attempt to grow a pale oak tree
+	set block at {_loc} to dirt # Make sure our tree can grow here
+	grow pale oak tree above {_loc}
+	set {_verify} to block 2 above {_loc}
+	assert {_verify} is pale oak log with "The pale oak tree should have grown"
+	cleanUpTree({_loc})