package com.ssomar.score.features.lang;

import com.ssomar.score.SCore;
import com.ssomar.score.features.FeatureSettingsInterface;
import com.ssomar.score.features.SavingVerbosityLevel;
import com.ssomar.score.menu.GUI;
import com.ssomar.score.utils.FixedMaterial;
import org.bukkit.Material;

import java.util.Arrays;
import java.util.Collections;

public enum FeatureSettingsSCoreEN implements FeatureSettingsInterface {
    DisplayFeatures("DisplayFeatures", "Display Features", new String[]{""}, Material.ITEM_FRAME),
    EXECUTABLEBLOCK("EXECUTABLEBLOCK", "Executable Block", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    EXECUTABLEBLOCKPLACED("EXECUTABLEBLOCKPLACED", "Executable Block Placed", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    EXECUTABLEEVENT("EXECUTABLEEVENT", "Executable Event", new String[]{}, Material.EMERALD),
    EXECUTABLEITEM("EXECUTABLEITEM", "Executable Item", new String[]{}, Material.EMERALD),
    EXECUTABLELEVER("EXECUTABLELEVER", "Executable Lever", new String[]{}, Material.LEVER),
    FURNITURE("FURNITURE", "Furniture", new String[]{}, Material.CHEST),
    FURNITUREPLACED("FURNITUREPLACED", "Furniture Placed", new String[]{}, Material.CHEST),
    RECIPE("RECIPE", "Recipe", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("CRAFTING_TABLE", "WORKBENCH"))),
    RECIPEGROUP("RECIPEGROUP", "Recipe Group", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("CRAFTING_TABLE", "WORKBENCH"))),
    HARDNESS("HARDNESS", "HARDNESS", new String[]{}, Material.BEDROCK),
    InteractionZoneFeatures("InteractionZoneFeatures", "Interaction Zone Features", new String[]{"&7&oMaintain F3 + b to see the zone"}, Material.ITEM_FRAME),
    SCREEN("SCREEN", "Screen", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    SCREENUNIT("SCREENUNIT", "Screen Unit", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    SPROJECTILE("SPROJECTILE", "SPROJECTILE", new String[]{}, Material.ARROW),
    TRADE("TRADE", "Trade", new String[]{""}, Material.GOLD_INGOT),
    VARIABLE("VARIABLE", "VARIABLE", new String[]{}, GUI.WRITABLE_BOOK),
    aboveValue("aboveValue", "Above Value", new String[]{"&7&oThe above value"}, GUI.CLOCK),
    activator("activator", "Activator", new String[]{"&7&oAn activator"}, Material.BEACON),
    activators("activators", "Activators", new String[]{"&7&oThe activators / triggers"}, Material.BEACON),
    activeTitle("activeTitle", "Active Title", new String[]{"&7&oActive the title"}, null),
    aligned("aligned", "Aligned", new String[]{"&7&oWhether the display will", "&7&obe aligned or not with", "&7&othe other blocks"}, Material.LEVER),
    allowedEntities("allowedEntities", "Allowed Entities", new String[]{"&7&oThe allowed entities"}, FixedMaterial.getMaterial(Arrays.asList("ZOMBIE_HEAD", "MONSTER_EGG"))),
    amount("amount", "Amount", new String[]{"&7&oThe amount"}, GUI.CLOCK),
    amountItemsTransferred("amountItemsTransferred", "Amount Items Transferred", new String[]{"&7&oWhitelist materials", "&7&oPut the materials", "&7&othat can be put in the container"}, Material.HOPPER),
    amplifier("amplifier", "Amplifier", new String[]{"&7&oThe amplifier of the potion effect"}, GUI.CLOCK),
    animation("animation", "Animation", new String[]{"&7&oThe animation"}, Material.ANVIL),
    armorColor("armorColor", "Armor Color", new String[]{"&7&oThe color of the armor"}, Material.LEATHER_CHESTPLATE),
    armorTrim("armorTrim", "Armor Trim", new String[]{"&7&oThe armor trim features"}, FixedMaterial.getMaterial(Arrays.asList("COAST_ARMOR_TRIM_SMITHING_TEMPLATE"))),
    aroundBlock("AroundBlock", "AroundBlock", new String[]{""}, Material.STONE),
    aroundBlockCdts("blockAroundCdts", "Around blocks cdt", new String[]{"&7&oThe around blocks cdt"}, Material.STONE),
    attribute("attribute", "Attribute", new String[]{"&7&oEdit the attribute"}, Material.PAPER),
    attributes("attributes", "Attributes", new String[]{"&7&oThe attributes"}, Material.PAPER),
    author("author", "Author", new String[]{"&7&oThe author"}, Material.NAME_TAG),
    autoUpdateFeatures("autoUpdateFeatures", "Auto Update Features", new String[]{"&7&oAuto update your EI"}, GUI.GRINDSTONE),
    autoUpdateItem("autoUpdateItem", "Auto Update Item", new String[]{"&7&oAutomatically update the item"}, null),
    bannerSettings("bannerSettings", "Banner Settings", new String[]{"&7&oBanner settings"}, FixedMaterial.getMaterial(Arrays.asList("CREEPER_BANNER_PATTERN", "BANNER"))),
    blacklistMaterials("blacklistMaterials", "Blacklist materials", new String[]{"&7&oBlacklist materials", "&7&oPut the materials", "&7&othat can't be put in the container"}, Material.CHEST),
    blockCommands("blockCommands", "Block Commands", new String[]{"&7&oThe block commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    blockCommands_target_block("blockCommands", "Target Block Commands", new String[]{"&7&oThe target block commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    blockConditions("blockConditions", "Block Conditions", new String[]{""}, Material.ANVIL),
    blockFaceOnPlace("blockFaceOnPlace", "Block face on place", new String[]{"&7&oThe block face when the block is placed"}, Material.COMPASS),
    blockLight("blockLight", "Block Light", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("LIGHT"))),
    blockState("blockState", "Block State", new String[]{"&7&oThe block state"}, Material.BRICK),
    blockStatePlus("blockStatePlus", "Block State Plus", new String[]{"&7&oThe block state plus"}, Material.BRICK),
    blockType("blockType", "Block type", new String[]{"&7&oThe type of the block"}, Material.STONE),
    blockTypeMustBe("blockTypeMustBe", "Block type must be", new String[]{"&7&oThe block type must be"}, GUI.WRITABLE_BOOK),
    blocks("blocks", "Blocks", new String[]{"&7&oBlocks"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    bookFeatures("bookFeatures", "Book Features", new String[]{"&7&oThe book features"}, GUI.WRITABLE_BOOK),
    bounce("bounce", "Bounce", new String[]{}, Material.SLIME_BLOCK),
    boundingBoxZone("boundingBoxZone", "boundingBoxZone", new String[]{""}, GUI.WRITABLE_BOOK),
    boundingBoxZones("boundingBoxZones", "boundingBoxZones", new String[]{}, GUI.WRITABLE_BOOK),
    brewingStandFeatures("brewingStandFeatures", "Brewing Stand Features", new String[]{"&7&oFeatures for", "&7&obrewing stand"}, Material.BREWING_STAND),
    brewingStandSpeed("brewingStandSpeed", "Brewing Stand speed", new String[]{"&7&oThe speed of the brewing stand"}, Material.BREWING_STAND),
    bundleContent("bundleContent", "Bundle Content", new String[]{"&7&oThe bundle content"}, FixedMaterial.getMaterial(Arrays.asList("BUNDLE"))),
    cameraOverlay("cameraOverlay", "Camera Overlay", new String[]{"&7&oThe camera overlay", "&7&oFormat: namespace:id", "&7&oWill reference model /assets/<namespace>/textures/<id>"}, FixedMaterial.getMaterial(Arrays.asList("BLUE_GLAZED_TERRACOTTA"))),
    canAlwaysEat("canAlwaysEat", "Can Always Eat", new String[]{"&7Can the player always eat this food?"}, null),
    canBeMoved("canBeMoved", "Can be moved", new String[]{"&7&oIf the block can be moved"}, Material.LEVER),
    canBeUsedOnlyByTheOwner("canBeUsedOnlyByTheOwner", "Can be used only by the owner", new String[]{"&7&oCan be used only by the owner", "&4⚠ &cRequire Store item info on &atrue"}, null),
    cancelActionEnchantInAnvil("cancel-enchant-anvil", "Cancel Action Enchant in Anvil", new String[]{"&7&oThe item can't be", "&7&oenchanted in an anvil"}, Material.ANVIL),
    cancelActionRenameInAnvil("cancel-rename-anvil", "Cancel Action Rename in Anvil", new String[]{"&7&oThe item can't be", "&7&orenamed in an anvil"}, Material.ANVIL),
    cancelAllCraft("cancel-item-craft", "Cancel All Craft", new String[]{"&7&oThe item can't be used", "&7&oto craft any item", "&7&o(Even custom items)"}, FixedMaterial.getMaterial(Arrays.asList("CRAFTING_TABLE", "WORKBENCH"))),
    cancelAnvil("cancel-anvil", "Cancel Anvil", new String[]{"&7&oThe item can't be", "&7&oplaced in an anvil"}, Material.ANVIL),
    cancelArmorStand("cancel-armorstand", "Cancel ArmorStand", new String[]{"&7&oThe item can't be", "&7&oplaced on an armorstand"}, Material.ARMOR_STAND),
    cancelBeacon("cancel-beacon", "Cancel Beacon", new String[]{"&7&oThe item can't be", "&7&oplaced in a beacon"}, Material.BEACON),
    cancelBrewing("cancel-brewing", "Cancel Brewing", new String[]{"&7&oThe item can't be", "&7&oplaced in a brewing stand"}, FixedMaterial.getBrewingStand()),
    cancelCartography("cancel-cartography", "Cancel Cartography", new String[]{"&7&oThe item can't be", "&7&oplaced in a cartography table"}, FixedMaterial.getMaterial(Collections.singletonList("CARTOGRAPHY_TABLE"))),
    cancelComposter("cancel-composter", "Cancel Composter", new String[]{"&7&oThe item can't be", "&7&oplaced in a composter"}, FixedMaterial.getMaterial(Collections.singletonList("COMPOSTER"))),
    cancelConsumption("cancel-consumption", "Cancel Consumption", new String[]{"&7&oThe item can't be", "&7&oconsumed"}, Material.POTION),
    cancelCraft("cancel-item-craft-no-custom", "Cancel Craft", new String[]{"&7&oThe item can't be used", "&7&oto craft vanilla item"}, FixedMaterial.getMaterial(Arrays.asList("CRAFTING_TABLE", "WORKBENCH"))),
    cancelCrafter("cancel-crafter", "Cancel Crafter", new String[]{"&7&oThe item can't be", "&7&oplaced in a crafter"}, FixedMaterial.getMaterial(Collections.singletonList("CRAFTER"))),
    cancelDecoratedPot("cancel-decorated-pot", "Cancel Decorated Pot", new String[]{"&7&oThe item can't be", "&7&oplaced in a decorated pot"}, FixedMaterial.getMaterial(Collections.singletonList("DECORATED_POT"))),
    cancelDepositInChest("cancel-deposit-in-chest", "Cancel Deposit in Chest", new String[]{"&7&oThe item can't be", "&7&oto deposit in a chest"}, Material.CHEST),
    cancelDepositInFurnace("cancel-deposit-in-furnace", "Cancel Deposit in Furnace", new String[]{"&7&oThe item can't be", "&7&oto deposit in a furnace"}, Material.FURNACE),
    cancelDispenser("cancel-dispenser", "Cancel Dispenser", new String[]{"&7&oThe item can't be", "&7&oplaced in a dispenser"}, Material.DISPENSER),
    cancelDropper("cancel-dropper", "Cancel Dropper", new String[]{"&7&oThe item can't be", "&7&oplaced in a dropper"}, Material.DROPPER),
    cancelEnchant("cancel-enchant", "Cancel Enchant", new String[]{"&7&oThe item can't be", "&7&oenchanted"}, FixedMaterial.getMaterial(Arrays.asList("ENCHANTING_TABLE", "ENCHANTMENT_TABLE"))),
    cancelEvent("cancelEvent", "Cancel Event", new String[]{"&7&oCancel the vanilla event"}, null),
    cancelEventIfError("cancelEventIfError", "Cancel Event If Error", new String[]{"&7&oCancel the event if not valid"}, null),
    cancelEventIfInCooldown("cancelEventIfInCooldown", "Cancel Event If In Cooldown", new String[]{"&7&oCancel the event if the player is in cooldown?"}, null),
    cancelEventIfMaxReached("cancelEventIfMaxReached", "Cancel event if max reached", new String[]{"&7&oCancel event if max reached"}, null),
    cancelEventIfNoPermission("cancelEventIfNoPermission", "Cancel Event If No Permission", new String[]{"&7&oCancel the event if the player has no permission"}, null),
    cancelEventIfNotOwner("cancelEventIfNotOwner", "Cancel event if not owner", new String[]{"&7&oCancel event if not owner"}, null),
    cancelEventIfNotValid("cancelEventIfNotValid", "Cancel event if not valid", new String[]{"&7&oCancel the event if the block is not valid?"}, null),
    cancelEvents("cancelEvents", "Cancel Events", new String[]{"&7&oThe cancel events features"}, Material.ANVIL),
    cancelGravity("cancelGravity", "Cancel gravity", new String[]{"&7&oIf the block has gravity"}, null),
    cancelGrindStone("cancel-grind-stone", "Cancel Grind Stone", new String[]{"&7&oThe item can't be", "&7&oplaced in a grind stone"}, FixedMaterial.getMaterial(Collections.singletonList("GRINDSTONE"))),
    cancelHopper("cancel-hopper", "Cancel Hopper", new String[]{"&7&oThe item can't be", "&7&oplaced in a hopper"}, Material.HOPPER),
    cancelHorn("cancel-horn", "Cancel Horn", new String[]{"&7&oThe horn can't be", "&7&ointeracted"}, FixedMaterial.getMaterial(Collections.singletonList("GOAT_HORN"))),
    cancelHorse("cancel-horse", "Cancel Horse", new String[]{"&7&oThe item can't be", "&7&oplaced in a horse"}, FixedMaterial.getMaterial(Arrays.asList("HORSE_SPAWN_EGG", "SADDLE"))),
    cancelItemBurn("cancel-item-burn", "Cancel Item Burn", new String[]{"&7&oThe item can't be", "&7&oburned"}, null),
    cancelItemDeleteByCactus("cancel-item-delete-by-cactus", "Cancel Item Delete by Cactus", new String[]{"&7&oThe item can't be", "&7&odeleted by cactus"}, Material.CACTUS),
    cancelItemDeleteByLightning("cancel-item-delete-by-lightning", "Cancel Item Delete by Lightning", new String[]{"&7&oThe item can't be", "&7&odeleted by lightning"}, FixedMaterial.getMaterial(Arrays.asList("LIGHTNING_ROD", "LEVER"))),
    cancelItemDrop("cancel-item-drop", "Cancel Item Drop", new String[]{"&7&oCancel the drop of the item"}, null),
    cancelItemFrame("cancel-item-frame", "Cancel Item Frame", new String[]{"&7&oThe item can't be", "&7&oplaced in an item frame"}, Material.ITEM_FRAME),
    cancelItemPlace("cancel-item-place", "Cancel Item Placement", new String[]{"&7&oCancel the placement of the item"}, null),
    cancelLectern("cancel-lectern", "Cancel Lectern", new String[]{"&7&oThe item can't be", "&7&oplaced in a lectern"}, FixedMaterial.getMaterial(Collections.singletonList("LECTERN"))),
    cancelLiquidDestroy("cancelLiquidDestroy", "Cancel liquid destroy", new String[]{"&7&oIf the block is destroyed by liquid"}, null),
    cancelLoom("cancel-loom", "Cancel Loom", new String[]{"&7&oThe item can't be", "&7&oplaced in a loom"}, FixedMaterial.getMaterial(Collections.singletonList("LOOM"))),
    cancelMerchant("cancel-merchant", "Cancel Merchant", new String[]{"&7&oThe item can't be", "&7&oplaced in a merchant"}, FixedMaterial.getMaterial(Arrays.asList("VILLAGER_SPAWN_EGG", "EMERALD"))),
    cancelSmithingTable("cancel-smithing-table", "Cancel Smithing Table", new String[]{"&7&oThe item can't be", "&7&oplaced in a smithing table"}, FixedMaterial.getMaterial(Collections.singletonList("SMITHING_TABLE"))),
    cancelStoneCutter("cancel-stone-cutter", "Cancel Stone Cutter", new String[]{"&7&oThe item can't be", "&7&oplaced in stone cutter"}, FixedMaterial.getMaterial(Collections.singletonList("STONECUTTER"))),
    cancelSwapHand("cancel-swap-hand", "Cancel Swap Hand", new String[]{"&7&oThe item can't be", "&7&oswapped in the hand"}, null),
    cancelToolInteractions("cancel-tool-interactions", "Cancel Tool Interactions", new String[]{"&7&oCancel the interactions of the tool"}, null),
    charged("charged", "Charged", new String[]{""}, Material.NETHER_STAR),
    chargedProjectiles("chargedProjectiles", "Charged Projectiles", new String[]{"&7&oThe charged projectiles"}, Material.ARROW),
    chiseledBookshelfFeatures("chiseledBookshelfFeatures", "ChiseledBookshelf Features", new String[]{"&7&oFeatures for", "&7&oChiseledBookshelf"}, FixedMaterial.getMaterial(Arrays.asList("CHISELED_BOOKSHELF", "BARRIER"))),
    clickToBreak("clickToBreak", "Click To Break", new String[]{"&7&oThe amount of click", "&7&orequired to break the EB"}, GUI.COMPARATOR),
    color("color", "Color", new String[]{"&7&oThe color"}, FixedMaterial.getMaterial(Arrays.asList("RED_DYE", "INK_SACK"))),
    colors("colors", "Colors", new String[]{"&7&oThe colors of the firework"}, GUI.CLOCK),
    commands_block("commands", "Block Commands", new String[]{"&7&oThe block commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    commands_player("commands", "Player Commands", new String[]{"&7&oThe player commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    comparator("comparator", "Comparator", new String[]{"&7&oThe comparator of the condition"}, Material.COMPASS),
    consoleCommands("consoleCommands", "Console Commands", new String[]{"&7&oThe console commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    consumableFeatures("consumableFeatures", "Consumable Features", new String[]{"&7&oConsumable Features"}, FixedMaterial.getMaterial(Arrays.asList("POTION"))),
    consumeSeconds("consumeSeconds", "Consume Seconds", new String[]{"&7&oThe consume seconds"}, GUI.CLOCK),
    containerContent("containerContent", "Container Content", new String[]{"&7&oThe container content"}, Material.CHEST),
    containerFeatures("containerFeatures", "Container Features", new String[]{"&7&oFeatures for", "&7&ochests, hoppers, .."}, Material.CHEST),
    containsMineInCube("containsMineInCube", "Contains Mine In Cube", new String[]{"&7&oCheck if the cube contains a mine"}, Material.TNT),
    cooldown("cooldown", "Cooldown", new String[]{"&7&oThe cooldown"}, GUI.CLOCK),
    cooldownGroup("cooldownGroup", "Cooldown Group", new String[]{"&7&oThe cooldown group"}, GUI.WRITABLE_BOOK),
    cooldownMsg("cooldownMsg", "Cooldown Message", new String[]{"&7&oThe cooldown message"}, GUI.WRITABLE_BOOK),
    cooldownFeatures("cooldownFeatures", "Cooldown Features", new String[]{"&7&oThe cooldown"}, GUI.CLOCK),
    cooldown_activators("activators", "Activators list", new String[]{"&7&oActivators list", "&eALL &7&ofor all activators"}, GUI.WRITABLE_BOOK),
    correctForDrops("correctForDrops", "Correct For Drops", new String[]{"&7&oSet whether or not this rule is considered", "&7&othe optimal tool for the blocks listed", "&7&oby this rule and will drop items."}, Material.LEVER),
    creationType("creationType", "CreationType", new String[]{"&7&oThe creation type"}, Material.COMPASS),
    checkAmount("checkAmount", "Check Amount", new String[]{"&7&oCheck the amount"}, null),
    anvilMergeType("anvilMergeType", "Anvil Merge Type", new String[]{"&7&oThe anvil merge type"}, Material.ANVIL),
    itemCommands("itemCommands", "Item Commands", new String[]{"&7&oThe item commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    checkDisplayName("checkDisplayName", "Check Display Name", new String[]{"&7&oCheck the display name"}, null),
    checkMaterial("checkMaterial", "Check Material", new String[]{"&7&oCheck the material"}, null),
    checkCustomModelData("checkCustomModelData", "Check Custom Model Data", new String[]{"&7&oCheck the custom model data"}, null),
    checkLore("checkLore", "Check Lore", new String[]{"&7&oCheck the lore"},null),
    checkDurability("checkDurability", "Check Durability", new String[]{"&7&oCheck the durability"}, null),
    checkExecutableItemID("checkExecutableItemID", "Check Executable Item ID", new String[]{"&7&oCheck the executable item ID"}, null),
    checkExecutableItemUsage("checkExecutableItemUsage", "Check Executable Item Usage", new String[]{"&7&oCheck the executable item usage"}, null),
    checkExecutableItemVariables("checkExecutableItemVariables", "Check Executable Item Variables", new String[]{"&7&oCheck the executable item variables"}, null),
    critical("critical", "Critical", new String[]{}, Material.DIAMOND_AXE),
    customConditions("customConditions", "Custom Conditions", new String[]{""}, Material.ANVIL),
    customModelData("customModelData", "Custom Model Data", new String[]{"&7&oThe custom model data"}, Material.ITEM_FRAME),
    customModelData_ei("customModelData", "Custom model data", new String[]{"&7&oThe custom model data of the item", "&7&oTo customize the item texture", "&2✔ &a&oTutorial in the wiki !"}, FixedMaterial.getMaterial(Arrays.asList("BLUE_GLAZED_TERRACOTTA"))),
    customName("customName", "Custom Name", new String[]{}, Material.NAME_TAG),
    customNameVisible("customNameVisible", "Custom Name Visible", new String[]{}, Material.NAME_TAG),
    customPitch("customPitch", "Custom Pitch", new String[]{"&7&oCustomize the pitch", "&7&orotation if needed"}, GUI.COMPARATOR),
    customStackSize("customStackSize", "Custom stack size", new String[]{"&7&oCustomize the stack size"}, Material.BUCKET),
    customY("customY", "Custom Y", new String[]{"&7&oCustomize the Y", "&7&olocation if needed"}, GUI.COMPARATOR),
    damage("damage", "Damage", new String[]{"&7&o-1 for vanilla damage"}, Material.DIAMOND_SWORD),
    damagePerBlock("damagePerBlock", "Damage Per Block", new String[]{"&7&oSet the amount of durability to be removed", "&7&ofrom the tool each time a block is broken."}, GUI.CLOCK),
    damageableOnHurt("damageableOnHurt", "Damageable On Hurt", new String[]{"&7&oThe item will take damage when the player is hurt"}, null),
    defaultMiningSpeed("defaultMiningSpeed", "Default Mining Speed", new String[]{"&7&oThe default mining speed of the tool"}, GUI.CLOCK),
    default_double("default", "Number Value", new String[]{"&7&oThe variable default value"}, GUI.WRITABLE_BOOK),
    default_list("default", "List Value", new String[]{"&7&oThe variable default value"}, GUI.WRITABLE_BOOK),
    default_string("default", "String Value", new String[]{"&7&oThe variable default value"}, GUI.WRITABLE_BOOK),
    delay("delay", "Delay", new String[]{"&7&oDelay between each activation", "&cMin: &65 ticks"}, GUI.CLOCK),
    damagePerAttack("damagePerAttack", "Durability Reduction Per Attack", new String[]{"&7&oThe amount of durability reduced per attack"}, GUI.CLOCK),
    disableBlockingTime("disableBlockingTime", "Disable Blocking Time", new String[]{"&7&oThe amount of time the target's", "&7shield will not work in seconds"}, GUI.CLOCK),
    delayInTick("delayInTick", "Delay in tick", new String[]{"&7&oIs the delay in ticks ?"}, null),
    delayOfTrade("delayOfTrade", "Delay Of Trade", new String[]{"&7&oThe delay of this trade", "&7&oIn &aseconds"}, GUI.CLOCK),
    desactiveDrops("desactiveDrops", "Remove Drops", new String[]{"&7&oRemove the drops"}, null),
    description("description", "Description", new String[]{"&7&oThe description of this trade"}, GUI.WRITABLE_BOOK),
    despawnDelay("despawnDelay", "Despawn Delay", new String[]{"&7&o-1 for vanilla despawn"}, Material.DEAD_BUSH),
    detailedBlocks("detailedBlocks", "Detailed Blocks", new String[]{"&7&oMake the activator run", "&7&oonly for certain blocks", "&7&oempty = all blocks"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    detailedClick("detailedClick", "Detailed Click", new String[]{"&7&oThe specific click"}, Material.COMPASS),
    weaponFeatures("weaponFeatures", "Weapon Features", new String[]{"&7&oThe weapon features"}, Material.DIAMOND_SWORD),
    detailedCommands("detailedCommands", "Detailed Commands", new String[]{"&7&oSpecify a list of commands that", "&7&ocan be affected", "&7&oempty = no command", "&7Example: &agamemode creative"}, GUI.WRITABLE_BOOK),
    detailedDamageCauses("detailedDamageCauses", "Detailed DamageCauses", new String[]{"&7&oSpecify a list of damageCauses that", "&7&ocan be affected", "&7&oempty = all causes"}, Material.BONE),
    detailedEffects("detailedEffects", "Detailed Effects", new String[]{"&7&oMake the activator run", "&7&oonly for certain effects", "&7&oempty = all effects"}, FixedMaterial.getMaterial(Arrays.asList("POTION", "REDSTONE"))),
    detailedEntities("detailedEntities", "Detailed Entities", new String[]{"&7&oSpecify a list of entities that", "&7&ocan be affected", "&7&oempty = all entities"}, FixedMaterial.getMaterial(Arrays.asList("ZOMBIE_HEAD", "MONSTER_EGG"))),
    detailedInventories("detailedInventories", "Detailed Inventories", new String[]{"&7&oSpecify a list of InventoryType accepted"}, GUI.WRITABLE_BOOK),
    detailedItems("detailedItems", "Detailed Items", new String[]{"&7&oMake the activator run", "&7&oonly for certain items", "&7&oempty = all items"}, FixedMaterial.getMaterial(Arrays.asList("TORCH"))),
    detailedMessagesContains("detailedMessagesContains", "Detailed Messages Contains", new String[]{"&7&oSpecify a list of messages accepted", "&7&o(Contains)", "&7&oempty = no command", "&7Example: &afriend"}, GUI.WRITABLE_BOOK),
    detailedMessagesEquals("detailedMessagesEquals", "Detailed Messages Equals", new String[]{"&7&oSpecify a list of messages accepted", "&7&o(Equals)", "&7&oempty = no command", "&7Example: &aHello my friend"}, GUI.WRITABLE_BOOK),
    detailedSlots("detailedSlots", "Detailed Slots", new String[]{"&7&oThe slots where the", "&7&oactivator will work"}, Material.ARMOR_STAND),
    detailedTargetBlocks("detailedTargetBlocks", "Detailed Target Blocks", new String[]{"&7&oSpecify a list of blocks that", "&7&ocan be affected", "&7&oempty = all blocks"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    detailedTargetEntities("detailedTargetEntities", "Detailed Target Entities", new String[]{"&7&oSpecify a list of entities that", "&7&ocan be affected", "&7&oempty = all entities"}, FixedMaterial.getMaterial(Arrays.asList("ZOMBIE_HEAD", "MONSTER_EGG"))),
    directionalFeatures("directionalFeatures", "Directional Features", new String[]{"&7&oFeatures for", "&7&odirectional"}, Material.COMPASS),
    disableEnchantGlide("disableEnchantGlide", "Disable Enchant Glide", new String[]{"&7&oDisable the enchant glide effect"}, Material.BEACON),
    disableStack("disableStack", "Disable stack", new String[]{"&7&oDisable item stacking ?"}, null),
    disabledWorlds("disabledWorlds", "Disabled worlds", new String[]{"&7&oDisabled worlds"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    dispensable("dispensable", "Dispensable", new String[]{"&7&oThe item can be dispensed"}, null),
    displayCommands("displayCommands", "Display Commands", new String[]{"&7&oThe display commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    displayConditions("displayConditions", "Display Conditions Features", new String[]{"&7&oDisplay conditions in the lore"}, GUI.WRITABLE_BOOK),
    displayConditions_conditions("displayConditions", "Display Conditions", new String[]{""}, Material.ANVIL),
    displayCooldownMessage("displayCooldownMessage", "Display Cooldown Message", new String[]{"&7&oDisplay the cooldown message"}, null),
    displayFeatures("displayFeatures", "Display Features", new String[]{"&7&oDisplay features"}, Material.ITEM_FRAME),
    displayNameDrop("displayNameDrop", "Display custom name", new String[]{"&7&oDisplay custom name above the item"}, null),
    dropBlockIfItIsBroken("dropBlockIfItIsBroken", "Drop block if it is broken", new String[]{"&7&oIf the block is broken,", "&7&oit will drop the block"}, Material.LEVER),
    dropBlockWhenItBurns("dropBlockWhenItBurns", "Drop block when it burns", new String[]{"&7&oIf the block burns,", "&7&oit will drop the block"}, Material.LEVER),
    dropBlockWhenItExplodes("dropBlockWhenItExplodes", "Drop block when it explodes", new String[]{"&7&oIf the block explodes,", "&7&oit will drop the block"}, Material.LEVER),
    dropFeatures("dropFeatures", "Drop Features", new String[]{"&7&oThe drop features"}, Material.ANVIL),
    dropType("dropType", "DropType", new String[]{"&7&oThe drop type"}, Material.COMPASS),
    durability("durability", "Durability", new String[]{"&7&oThe durability of the item"}, Material.ANVIL),
    durability_features("durability", "Durability Features", new String[]{"&7&oDurability features"}, Material.ANVIL),
    duration("duration", "Duration", new String[]{"&7&oThe duration of the potion effect", "&4⚠ &cIn ticks !", "&7&o1 sec = 20 ticks"}, GUI.CLOCK),
    eastValue("eastValue", "East Value", new String[]{"&7&oThe east value"}, GUI.CLOCK),
    eatSeconds("eatSeconds", "Eat Seconds", new String[]{"&7The time in seconds to eat the food"}, GUI.CLOCK),
    editorIcon("editorIcon", "Icon Editor", new String[]{}, Material.LEVER),
    effects("effects", "Effects", new String[]{"&7&oThe effects"}, FixedMaterial.getMaterial(Arrays.asList("POTION", "REDSTONE"))),
    enable("enable", "Enable", new String[]{"&7&oEnable the tool features"}, Material.LEVER),
    enableArmorTrim("enableArmorTrim", "Enable Armor Trim", new String[]{"&7&oEnable armor trim"}, null),
    enableFeature("enableFeature", "Enable Feature", new String[]{"&7&oEnable or disable this feature"}, null),
    enableRarity("enableRarity", "Enable Rarity", new String[]{"&7&oEnable or disable the rarity feature"}, null),
    enableSound("enableSound", "Enable Sound", new String[]{"&7&oEnable the sound"}, null),
    enableVisualCooldown("enableVisualCooldown", "Enable Visual Cooldown", new String[]{"&7&oEnable the visual cooldown", "&7&oIt requires to have setup", "&e&ocooldownGroup &7&oin the item settings"}, null),
    enabled("enabled", "Enabled", new String[]{"&7&oIf the event is enabled"}, null),
    enchantment("enchantment", "Enchantment", new String[]{"&7&oThe enchantment"}, Material.ENCHANTED_BOOK),
    enchantmentWithLevel("enchantmentWithLevel", "Enchantment with level", new String[]{"&7&oAn enchantment with level"}, Material.ENCHANTED_BOOK),
    enchantments("enchantments", "Enchantments", new String[]{"&7&oThe enchantments of the item"}, Material.ENCHANTED_BOOK),
    endDate("endDate", "End Date", new String[]{"&7&oThe end date"}, GUI.CLOCK),
    entityCommands("entityCommands", "Entity Commands", new String[]{"&7&oThe entity commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    entityConditions("entityConditions", "Entity Conditions", new String[]{""}, Material.ANVIL),
    entityCooldownFeatures("entityCooldownFeatures", "Entity Cooldown Features", new String[]{"&7&oThe entity cooldown"}, GUI.CLOCK),
    entityType("entityType", "Entity Type", new String[]{"&7&oThe entity type"}, FixedMaterial.getMaterial(Arrays.asList("ZOMBIE_HEAD", "MONSTER_EGG"))),
    equipModel("equipModel", "Equip Model", new String[]{"&7&oThe equip/armor model", "&7&oFormat: namespace:id", "&7&oWill reference model /assets/<namespace>/models/equipment/<id>"}, FixedMaterial.getMaterial(Arrays.asList("BLUE_GLAZED_TERRACOTTA"))),
    equippableFeatures("equippableFeatures", "Equippable Features", new String[]{"&7&oThe equippable features"}, Material.DIAMOND_CHESTPLATE),
    errorMessage("errorMessage", "Error message", new String[]{"&7&oThe error message"}, GUI.WRITABLE_BOOK),
    errorMsg("errorMsg", "Error Message", new String[]{"&7&oThe error message"}, GUI.WRITABLE_BOOK),
    executableItem("executableItem", "Executable Item", new String[]{"&7&oSpecify an ExecutableItem required"}, Material.DIAMOND),
    fadeColors("fadeColors", "Fade Colors", new String[]{"&7&oThe fade colors of the firework"}, GUI.CLOCK),
    fireworkColor("fireworkColor", "Firework Color", new String[]{"&7&oThe color of the firework"}, FixedMaterial.getMaterial(Arrays.asList("FIREWORK_STAR", "FIREWORK_CHARGE"))),
    fireworkExplosion("fireworkExplosion", "Firework Explosion", new String[]{"&7&oThe explosion of the firework"}, FixedMaterial.getMaterial(Arrays.asList("FIREWORK_STAR"))),
    fireworkExplosions("fireworkExplosions", "Firework Explosions", new String[]{"&7&oThe explosions of the firework"}, FixedMaterial.getMaterial(Arrays.asList("FIREWORK_STAR"))),
    fireworkFeatures("fireworkFeatures", "Firework Features", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("FIREWORK_ROCKET"))),
    foodFeatures("foodFeatures", "Food Features", new String[]{"&7&oFood features"}, Material.COOKED_BEEF),
    for_("for", "For", new String[]{"&7&oFor"}, GUI.COMPARATOR),
    forceBlockFaceOnPlace("forceBlockFaceOnPlace", "Force block face on place", new String[]{"&7&oForce the block face when the block is placed"}, Material.LEVER),
    fortuneChance("fortuneChance", "Fortune Chance", new String[]{"&7&oThe chance to get bonus items", "&7&oMin: &e0 &7&o/ Max: &e1"}, Material.FURNACE),
    fortuneMultiplier("fortuneMultiplier", "Fortune Multiplier", new String[]{"&7&oThe multiplier of the fortune effect"}, Material.FURNACE),
    from("from", "From", new String[]{""}, GUI.CLOCK),
    furnaceFeatures("furnaceFeatures", "Furnace Features", new String[]{"&7&oFeatures for", "&7&ofurnaces"}, Material.FURNACE),
    furnaceSpeed("furnaceSpeed", "Furnace speed", new String[]{"&7&oThe speed of the furnace"}, Material.FURNACE),
    giveFirstJoin("giveFirstJoin", "Give first join", new String[]{"&7&oEnable the feature"}, null),
    giveFirstJoinAmount("giveFirstJoinAmount", "Amount", new String[]{"&7&oThe amount to give"}, GUI.CLOCK),
    giveFirstJoinFeatures("giveFirstJoinFeatures", "Give first join features", new String[]{"&7&oThe give first join features"}, Material.ANVIL),
    giveFirstJoinSlot("giveFirstJoinSlot", "Slot", new String[]{"&7&oSlot between 0 and 8 includes"}, GUI.CLOCK),
    glider("glider", "Glider", new String[]{"&7&oThe glider"}, FixedMaterial.getMaterial(Arrays.asList("ELYTRA"))),
    globalCooldownFeatures("globalCooldownFeatures", "Global Cooldown Features", new String[]{"&7&oThe global cooldown", "&7&o(For &eALL &7&oplayers and entities)"}, GUI.CLOCK),
    glow("glow", "Item Glow", SCore.is1v20v5Plus() ? new String[]{"&7&oItem Glowing effect"} : new String[]{"&7&oItem glowing effect", "&4⚠ &cIt adds an useless enchant", "&c+ hide enchants"}, Material.BEACON),
    glowColor("glowColor", "Glow Color", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("RED_DYE", "INK_SACK"))),
    glowDrop("glowDrop", "Glow drop", new String[]{"&7&oGlow drop"}, null),
    glowDropColor("glowDropColor", "Glow Drop Color", new String[]{"&7&oThe color of the glow"}, Material.REDSTONE),
    glowDuration("glowDuration", "Glow Duration", new String[]{"&7&oThe duration of the glow effect"}, GUI.CLOCK),
    glowWhenPowered("glowWhenPowered", "Glow when powered", new String[]{"&7&oGlow when powered"}, GUI.CLOCK),
    glowWhenTrade("glowWhenTrade", "Glow When Trade", new String[]{"&7&oPiglin glow during the trade"}, Material.GLOWSTONE),
    glowing("glowing", "Glowing", new String[]{}, Material.BEACON),
    gravity("gravity", "Gravity", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("ELYTRA", "FEATHER"))),
    hasConsumeParticles("hasConsumeParticles", "Has Consume Particles", new String[]{"&7&oHas consume particles"}, Material.ANVIL),
    hasExecutableItem("hasExecutableItem", "Has Executable Item", new String[]{"&7&oThe has ExecutableItem feature"}, Material.DIAMOND),
    hasIcon("hasIcon", "Icon", new String[]{"&7&oIf the potion effect has an icon"}, null),
    hasItem("hasItem", "Has Item", new String[]{"&7&oThe has item feature"}, Material.STONE),
    hasParticles("hasParticles", "Particles", new String[]{"&7&oIf the potion effect has particles"}, null),
    hasTrail("hasTrail", "Has Trail", new String[]{"&7&oWhether or not the explosion has a trail effect (diamond)."}, null),
    hasTwinkle("hasTwinkle", "Has Twinkle", new String[]{"&7&oWhether or not the explosion has a twinkle effect (glowstone dust)."}, null),
    headDBID("headDBID", "HeadDB ID", new String[]{"&7&oThe HeadDB ID of the head", "&7&oWork with: ", "&7&o- &bHeadDB(Free)", "&7&o- &cHead Database(Prem)"}, FixedMaterial.getHead()),
    headFeatures("headFeatures", "Head Features", new String[]{"&7&oTextures for the head"}, FixedMaterial.getHead()),
    headValue("headValue", "Head Value", new String[]{"&7&oThe value of the head", "&eminecraft-heads.com"}, FixedMaterial.getHead()),
    height("height", "Height", new String[]{"&7&oMaintain F3 + b to see the zone"}, GUI.CLOCK),
    hideAdditionalTooltip("hideAdditionalTooltip", "Hide additional tooltip", new String[]{"&7&oHide additional tooltip"}, null),
    hideArmorTrim("hideArmorTrim", "Hide armor trim", new String[]{"&7&oHide armor trim"}, null),
    hideAttributes("hideAttributes", "Hide attributes", new String[]{"&7&oHide attributes"}, null),
    hideDestroys("hideDestroys", "Hide destroys", new String[]{"&7&oHide destroys"}, null),
    hideDye("hideDye", "Hide dye", new String[]{"&7&oHide dye"}, null),
    hideEnchantments("hideEnchantments", "Hide enchantments", new String[]{"&7&oHide enchantments"}, null),
    hidePlacedOn("hidePlacedOn", "Hide placed on", new String[]{"&7&oHide placed on"}, null),
    hidePotionEffects("hidePotionEffects", "Hide potion effects / banner tags", new String[]{"&7&oHide Potion effects", "&7&oand banner tags"}, null),
    hideTooltip("hideToolTip", "Hide tool tip", new String[]{"&7&oHide tool tip"}, null),
    hideUnbreakable("hideUnbreakable", "Hide unbreakable", new String[]{"&7&oHide unbreakable"}, null),
    hideUsage("hideUsage", "Hide usage", new String[]{"&7&oHide usage"}, null),
    hiders("hiders", "Hiders", new String[]{"&7&oThe hiders features", "&7&oHiders to hide:", "&7&oAttributes, Enchants, ..."}, Material.ANVIL),
    hitSound("hitSound", "Hit Sound", new String[]{"&7&oThe hit sound"}, Material.NOTE_BLOCK),
    hopperFeatures("hopperFeatures", "Hopper Features", new String[]{"&7&oFeatures for", "hoppers, .."}, Material.HOPPER),
    icon("icon", "Icon", new String[]{}, Material.STONE),
    ifAdult("ifAdult", "If adult", new String[]{}, Material.ANVIL),
    ifBaby("ifBaby", "If baby", new String[]{}, Material.ANVIL),
    ifBlockAge("ifBlockAge", "If block age", new String[]{}, Material.ANVIL),
    ifBlockLocationX("ifBlockLocationX", "If block location X", new String[]{}, Material.ANVIL),
    ifBlockLocationY("ifBlockLocationY", "If block location Y", new String[]{}, Material.ANVIL),
    ifBlockLocationZ("ifBlockLocationZ", "If block location Z", new String[]{}, Material.ANVIL),
    ifBlocking("ifBlocking", "If blocking", new String[]{}, null),
    ifCanBreakTargetedBlock("ifCanBreakTargetedBlock", "If Can Break Targeted Block", new String[]{}, Material.ANVIL),
    ifContainerContains("ifContainerContains", "If container contains", new String[]{}, Material.ANVIL),
    ifContainerContainsEI("ifContainerContainsEI", "If container contains EI", new String[]{}, Material.ANVIL),
    ifContainerContainsSellableItems("ifContainerContainsSellableItems", "If container contains sellable items", new String[]{}, Material.ANVIL),
    ifContainerEmpty("ifContainerEmpty", "If container empty", new String[]{}, Material.ANVIL),
    ifContainerNotEmpty("ifContainerNotEmpty", "If container not empty", new String[]{}, Material.ANVIL),
    ifCrossbowMustBeCharged("ifCrossbowMustBeCharged", "If crossbow must be charged", new String[]{}, FixedMaterial.getMaterial(Collections.singletonList("CROSSBOW"))),
    ifCrossbowMustNotBeCharged("ifCrossbowMustNotBeCharged", "If crossbow must not be charged", new String[]{}, FixedMaterial.getMaterial(Collections.singletonList("CROSSBOW"))),
    ifCursorDistance("ifCursorDistance", "If cursor distance", new String[]{}, Material.ANVIL),
    ifDurability("ifDurability", "If durability", new String[]{}, Material.ANVIL),
    ifUseCooldown("ifUseCooldown", "If use cooldown", new String[]{}, Material.ANVIL),
    ifEntityHealth("ifEntityHealth", "If entity health", new String[]{}, Material.ANVIL),
    ifFlying("ifFlying", "If flying", new String[]{}, null),
    ifFromSpawner("ifFromSpawner", "If from spawner", new String[]{}, Material.ANVIL),
    ifFrozen("ifFrozen", "If frozen", new String[]{}, Material.ANVIL),
    ifGliding("ifGliding", "If gliding", new String[]{}, null),
    ifGlowing("ifGlowing", "If glowing", new String[]{}, Material.ANVIL),
    ifHasAI("ifHasAI", "If has AI", new String[]{}, Material.ANVIL),
    ifHasEnchant("ifHasEnchant", "If has enchant", new String[]{"&7If has enchant condition"}, Material.ANVIL),
    ifHasExecutableItems("ifHasExecutableItems", "If has ExecutableItems", new String[]{}, Material.DIAMOND),
    ifHasItems("ifHasItems", "If has items", new String[]{}, Material.STONE),
    ifHasNotEnchant("ifHasNotEnchant", "If has not enchant", new String[]{"&7If has not enchant condition"}, Material.ANVIL),
    ifHasNotExecutableItems("ifHasNotExecutableItems", "If has not ExecutableItems", new String[]{}, Material.DIAMOND),
    ifHasNotItems("ifHasNotItems", "If has not items", new String[]{}, Material.STONE),
    ifHasPermission("ifHasPermission", "If has permission", new String[]{}, Material.ANVIL),
    ifHasSaddle("ifHasSaddle", "If has Saddle", new String[]{}, Material.ANVIL),
    ifHasTag("ifHasTag", "If has tag", new String[]{"&7&oThe whitelisted tags"}, Material.ANVIL),
    ifInBiome("ifInBiome", "If in biome", new String[]{}, Material.ANVIL),
    ifInRegion("ifInRegion", "If in region", new String[]{}, Material.ANVIL),
    ifInWorld("ifInWorld", "If in world", new String[]{}, Material.ANVIL),
    ifInvulnerable("ifInvulnerable", "If invulnerable", new String[]{}, Material.ANVIL),
    ifIsInTheAir("ifIsInTheAir", "If is in the air", new String[]{}, null),
    ifIsInTheBlock("ifIsInTheBlock", "If is in the block", new String[]{}, Material.ANVIL),
    ifIsNotInTheAir("ifIsNotInTheAir", "If is not in the air", new String[]{}, null),
    ifIsNotInTheBlock("ifIsNotInTheBlock", "If is not in the block", new String[]{}, Material.ANVIL),
    ifIsNotOnFire("ifIsNotOnFire", "If is not on fire", new String[]{}, null),
    ifIsNotOnTheBlock("ifIsNotOnTheBlock", "If is not on the block", new String[]{}, Material.ANVIL),
    ifIsOnFire("ifIsOnFire", "If is on fire", new String[]{}, null),
    ifIsOnTheBlock("ifIsOnTheBlock", "If is on the block", new String[]{}, Material.ANVIL),
    ifIsPowered("ifIsPowered", "If is powered", new String[]{}, Material.ANVIL),
    ifLightLevel("ifLightLevel", "If light level", new String[]{}, Material.ANVIL),
    ifMustBeNatural("ifMustBeNatural", "If must be natural", new String[]{}, Material.ANVIL),
    ifMustBeNotNatural("ifMustBeNotNatural", "If must be not natural", new String[]{}, Material.ANVIL),
    ifMustBeNotPowered("ifMustBeNotPowered", "If must be not powered", new String[]{}, Material.ANVIL),
    ifMustBeEB("ifMustBeEB", "If must be EB", new String[]{}, Material.ANVIL),
    ifName("ifName", "If name", new String[]{}, Material.ANVIL),
    ifNamed("ifNamed", "If named", new String[]{}, Material.ANVIL),
    ifNeedPlayerConfirmation("ifNeedPlayerConfirmation", "If need player confirmation", new String[]{}, null),
    ifNoPlayerMustBeOnTheBlock("ifNoPlayerMustBeOnTheBlock", "If no player must be on the block", new String[]{}, Material.ANVIL),
    ifNotBlocking("ifNotBlocking", "If not blocking", new String[]{}, null),
    ifNotEntityType("ifNotEntityType", "If not entityType", new String[]{}, Material.ANVIL),
    ifNotFlying("ifNotFlying", "If not flying", new String[]{}, null),
    ifNotFromSpawner("ifNotFromSpawner", "If not from spawner", new String[]{}, Material.ANVIL),
    ifNotGliding("ifNotGliding", "If not gliding", new String[]{}, null),
    ifNotHasAI("ifNotHasAI", "If has not AI", new String[]{}, Material.ANVIL),
    ifNotHasPermission("ifNotHasPermission", "If not has permission", new String[]{}, Material.ANVIL),
    ifNotHasSaddle("ifNotHasSaddle", "If not has Saddle", new String[]{}, Material.ANVIL),
    ifNotHasTag("ifNotHasTag", "If not has tag", new String[]{"&7&oThe blacklisted tags"}, Material.ANVIL),
    ifNotInBiome("ifNotInBiome", "If not in biome", new String[]{}, Material.ANVIL),
    ifNotInRegion("ifNotInRegion", "If not in region", new String[]{}, Material.ANVIL),
    ifNotInWorld("ifNotInWorld", "If not in world", new String[]{}, Material.ANVIL),
    ifNotNamed("ifNotNamed", "If not named", new String[]{}, Material.ANVIL),
    ifNotOwnerOfTheEI("ifNotOwnerOfTheEI", "If not owner of the EI", new String[]{}, null),
    ifNotSneaking("ifNotSneaking", "If not sneaking", new String[]{}, null),
    ifNotSprinting("ifNotSprinting", "If not sprinting", new String[]{}, null),
    ifNotStunned("ifNotStunned", "If not stunned", new String[]{"&7&oBy the custom player", "&7&ocommand &eSTUN_ENABLE"}, null),
    ifNotSwimming("ifNotSwimming", "If not swimming", new String[]{}, null),
    ifNotTamed("ifNotTamed", "If not tamed", new String[]{}, Material.ANVIL),
    ifNotTargetBlock("ifNotTargetBlock", "If not target block", new String[]{}, Material.ANVIL),
    ifOnFire("ifOnFire", "If on fire", new String[]{}, Material.ANVIL),
    ifOwnerOfTheEI("ifOwnerOfTheEI", "If owner of the EI", new String[]{}, null),
    ifPlantFullyGrown("ifPlantFullyGrown", "If plant fully grown", new String[]{}, Material.ANVIL),
    ifPlantNotFullyGrown("ifPlantNotFullyGrown", "If plant not fully grown", new String[]{}, Material.ANVIL),
    ifPlayerEXP("ifPlayerEXP", "If player EXP", new String[]{}, Material.ANVIL),
    ifPlayerFoodLevel("ifPlayerFoodLevel", "If player food level", new String[]{}, Material.ANVIL),
    ifPlayerHasEffect("ifPlayerHasEffect", "If player has effect", new String[]{}, Material.ANVIL),
    ifPlayerHasEffectEquals("ifPlayerHasEffectEquals", "If player has effect equals", new String[]{}, Material.ANVIL),
    ifPlayerHealth("ifPlayerHealth", "If player health", new String[]{}, Material.ANVIL),
    ifPlayerLevel("ifPlayerLevel", "If player level", new String[]{}, Material.ANVIL),
    ifPlayerMounts("ifPlayerMounts", "If player mounts", new String[]{}, Material.ANVIL),
    ifPlayerMustBeInHisTown("ifPlayerMustBeInHisTown", "If player must be in his town", new String[]{}, null),
    ifPlayerMustBeOnHisClaim("ifPlayerMustBeOnHisClaim", "If player must be on his claim", new String[]{}, null),
    ifPlayerMustBeOnHisClaimOrWilderness("ifPlayerMustBeOnHisClaimOrWilderness", "If player must be on his claim or wilderness", new String[]{}, null),
    ifPlayerMustBeOnHisIsland("ifPlayerMustBeOnHisIsland", "If player must be on his island", new String[]{}, null),
    ifPlayerMustBeOnHisPlot("ifPlayerMustBeOnHisPlot", "If player must be on his plot", new String[]{}, null),
    ifPlayerMustBeOnTheBlock("ifPlayerMustBeOnTheBlock", "If player must be on the block", new String[]{}, Material.ANVIL),
    ifPlayerNotHasEffect("ifPlayerNotHasEffect", "If player not has effect", new String[]{}, Material.ANVIL),
    ifPlayerNotMounts("ifPlayerNotMounts", "If player not mounts", new String[]{}, Material.ANVIL),
    ifPosX("ifPosX", "If player posX", new String[]{}, Material.ANVIL),
    ifPosY("ifPosY", "If player posY", new String[]{}, Material.ANVIL),
    ifPosZ("ifPosZ", "If player posZ", new String[]{}, Material.ANVIL),
    ifPowered("ifPowered", "If powered", new String[]{}, Material.ANVIL),
    ifSneaking("ifSneaking", "If sneaking", new String[]{}, null),
    ifSprinting("ifSprinting", "If sprinting", new String[]{}, null),
    ifStunned("ifStunned", "If stunned", new String[]{"&7&oBy the custom player", "&7&ocommand &eSTUN_ENABLE"}, null),
    ifSwimming("ifSwimming", "If swimming", new String[]{}, null),
    ifTamed("ifTamed", "If tamed", new String[]{}, Material.ANVIL),
    ifTargetBlock("ifTargetBlock", "If target block", new String[]{}, Material.ANVIL),
    ifUsage("ifUsage", "If usage", new String[]{}, Material.ANVIL),
    ifWeather("ifWeather", "If weather", new String[]{"&7The whitelisted weathers"}, Material.ANVIL),
    ifWorldTime("ifWorldTime", "If world time", new String[]{}, Material.ANVIL),
    ignoreKeepDefaultAttributesFeature("ignoreKeepDefaultAttributesFeature", "Ignore Keep Default Attributes Feature", new String[]{"&7&oFor new item LET IT FALSE PLS", "&7&oOtherwise you can let it true", "&7&oif you want to update your old items turn it FALSE", "&7&oBut be careful the item tags may change", "&7&oit can impact shopkeeper or custom craft recipe", "&7&oOnly for 1.19+"}, null),
    incendiary("incendiary", "Incendiary", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("CAMPFIRE", "FLINT_AND_STEEL"))),
    infiniteFuel("infiniteFuel", "Infinite Fuel", new String[]{"&7&oThe furnace will have infinite Fuel"}, Material.FURNACE),
    infiniteVisualLit("infiniteVisualLit", "Infinite Visual Lit", new String[]{"&7&oThe furnace will always lit but only visual"}, Material.FURNACE),
    instrument("instrument", "Instrument", new String[]{"&7&oThe instrument"}, Material.NOTE_BLOCK),
    instrumentFeatures("instrumentFeatures", "Instrument Features", new String[]{"&7&oThe instrument features"}, Material.NOTE_BLOCK),
    interactionRange("interactionRange", "Interaction Range", new String[]{"&7&oThe interaction range"}, GUI.CLOCK),
    interactionUUID("interactionUUID", "interaction UUID", new String[]{"&7&oUUID of the interaction"}, GUI.CLOCK),
    inventoryTitle("inventoryTitle", "Inventory title", new String[]{"&7&oThe title of the inventory"}, Material.NAME_TAG),
    invisible("invisible", "Invisible", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("GLASS_PANE", "GLASS"))),
    input1("input1", "Input 1", new String[]{}, Material.GLASS),
    input2("input2", "Input 2", new String[]{}, Material.GLASS),
    input3("input3", "Input 3", new String[]{}, Material.GLASS),
    input4("input4", "Input 4", new String[]{}, Material.GLASS),
    input5("input5", "Input 5", new String[]{}, Material.GLASS),
    input6("input6", "Input 6", new String[]{}, Material.GLASS),
    input7("input7", "Input 7", new String[]{}, Material.GLASS),
    input8("input8", "Input 8", new String[]{}, Material.GLASS),
    input9("input9", "Input 9", new String[]{}, Material.GLASS),
    isAmbient("isAmbient", "Ambient", new String[]{"&7&oIf the potion effect is ambient"}, null),
    isCollidable("isCollidable", "Is Collidable", new String[]{"&c&oEXPERIMENTAL"}, null),
    isCooldownInTicks("isCooldownInTicks", "Cooldown in ticks", new String[]{"&7&oIs the cooldown in ticks?"}, null),
    isDurabilityBasedOnUsage("isDurabilityBasedOnUsage", "Durability based on usage", new String[]{"&7&oThe durability feature", "&7&owill be ignored, and the usage", "&7&ofeature will be used as durability"}, null),
    isLocked("isLocked", "Is locked", new String[]{"&7&oIs the container locked?"}, null),
    isMeat("isMeat", "Is Meat", new String[]{"&7Is the food meat?"}, null),
    isRefreshableClean("isRefreshableClean", "Is Refreshable Clean", new String[]{"&7&oIs refreshable clean"}, null),
    itemCheckerType("itemCheckerType", "Item Checker Type", new String[]{"&7&oThe item checker type"}, Material.ANVIL),
    itemCheckers("itemCheckers", "Item Checkers", new String[]{"&7&oThe item checkers"}, Material.ANVIL),
    itemConditions("itemConditions", "Item Conditions", new String[]{""}, Material.ANVIL),
    itemModel("itemModel", "Item Model", new String[]{"&7&oThe item model", "&7&oFormat: namespace:id", "&7&oWill reference model /assets/<namespace>/models/item/<id>"}, FixedMaterial.getMaterial(Arrays.asList("BLUE_GLAZED_TERRACOTTA"))),
    itemRarity("itemRarity", "Item Rarity", new String[]{"&7&oThe rarity of the item"}, Material.EMERALD),
    items("items", "Items", new String[]{"&7&oItems"}, FixedMaterial.getMaterial(Arrays.asList("TORCH"))),
    itemsAdder("itemsAdder", "Items Adder", new String[]{"&7&oThe item required to", "&7&oexecute this trade"}, Material.DIAMOND),
    itemsAdderID("itemsAdderID", "ItemsAdder", new String[]{"&7&oThe itemsAdderBlock ID"}, Material.DIAMOND_BLOCK),
    keepDefaultAttributes("keepDefaultAttributes", "Keep Default Attributes", new String[]{"&7&oKeep the default attributes", "&7&oOnly for 1.19+"}, null),
    keepItemOnDeath("keepItemOnDeath", "Keep item on death", new String[]{"&7&oKeep the item on death ?"}, Material.BONE),
    knockbackStrength("knockbackStrength", "Knockback Strength", new String[]{}, Material.CHAINMAIL_CHESTPLATE),
    level("level", "Level", new String[]{"&7&oThe level of the enchantment"}, Material.BEACON),
    leverUUID("leverUUID", "lever UUID", new String[]{"&7&oUUID of the lever"}, GUI.CLOCK),
    lifeTime("lifeTime", "Life time", new String[]{"&7&oThe flight duration of this firework rocket", "&7&oi.e. the number of gunpowders used to craft it,", "&7&oMust be an integer between -128 and 127. Defaults to 1"}, GUI.CLOCK),
    lockedInventory("locked-in-inventory", "Locked Inventory", new String[]{"&7&oThe item can't be", "&7&omoved of the inventory"}, Material.BARRIER),
    lockedName("lockedName", "Locked name", new String[]{"&7&oThe name of the item", "&7&othat can unlock the container"}, Material.NAME_TAG),
    loop("loop", "Loop features", new String[]{"&7&oSpecific settings", "&7&ofor the loop activator"}, Material.ANVIL),
    lore("lore", "Lore", new String[]{"&7&oThe lore of the item"}, Material.PAPER),
    magicID("magicID", "Magic ID", new String[]{"&7&oThe Magic ID"}, Material.STONE),
    material("material", "Material", new String[]{"&7&oThe material"}, Material.STONE),
    materialAndTags("materialAndTags", "Material and Tags", new String[]{"&7&oThe material and tags"}, Material.STONE),
    materials("blocks", "Block Materials", new String[]{"&7&oThe materials impacted by this rule"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    maxDistanceBoundingBoxCalculation("maxDistanceBoundingBoxCalculation", "Max Distance Bounding Box Calculation", new String[]{"&7&oThe max distance for the bounding box calculation", "&7&oKeep it low 3-5 if you have FPS issue"}, GUI.CLOCK),
    maxDurability("maxDurability", "Max Durability", new String[]{"&7&oMax durability feature"}, Material.ANVIL),
    maxFurnitureRendered("maxFurnitureRendered", "Max Furniture Rendered", new String[]{"&7&oThe max furniture rendered"}, GUI.CLOCK),
    maxUsePerDay("maxUsePerDay", "Max use per day", new String[]{"&7&oMax use per day", "&a-1 &7&o= infinite"}, Material.BUCKET),
    messageIfMaxReached("messageIfMaxReached", "Message if max reached", new String[]{"&7&oMessage if max reached"}, GUI.WRITABLE_BOOK),
    messageIfNotValid("messageIfNotValid", "Message if not valid", new String[]{"&7&oMessage if the condition is not valid?"}, GUI.WRITABLE_BOOK),
    messageIfNotValidForTarget("messageIfNotValidForTarget", "Message if not valid For Target", new String[]{"&7&oThe message to display if", "&7&othe condition is not valid for the target"}, GUI.WRITABLE_BOOK),
    miningSpeed("miningSpeed", "Mining speed", new String[]{"&7&oThe mining speed of the tool"}, GUI.CLOCK),
    modification_double("modification", "Double Update", new String[]{"&7&oThe number update"}, GUI.WRITABLE_BOOK),
    modification_string("modification", "String Update", new String[]{"&7&oThe string update"}, GUI.WRITABLE_BOOK),
    multiChoices("multi-choices", "Multi Choices", new String[]{}, Material.DIAMOND),
    mustBeAProjectileLaunchWithTheSameEI("mustBeAProjectileLaunchWithTheSameEI", "Must Be A Projectile Launch With The Same EI", new String[]{"&7&oMust be a projectile", "&7&olaunch with the same EI"}, Material.ARROW),
    mustBeItsOwnInventory("mustBeItsOwnInventory", "Must Be Its Own Inventory", new String[]{"&7&oThe player must open in its own inventory"}, Material.LEVER),
    myFurnitureFeatures("myFurnitureFeatures", "MyFurniture Features", new String[]{"&7&oMyFurniture Features"}, FixedMaterial.getMaterial(Arrays.asList("BOOKSHELF"))),
    myfurnitureID("myfurnitureID", "MyFurniture ID", new String[]{"&7&oThe MyFurniture ID"}, FixedMaterial.getMaterial(Arrays.asList("BOOKSHELF"))),
    name("name", "Name", new String[]{"&7&oThe name or display name"}, Material.NAME_TAG),
    nbt("nbt", "NBT Tags", new String[]{"&7&oThe NBT tags features", "&7&oRequires the plugin &eNBTAPI"}, Material.NAME_TAG),
    noActivatorRunIfTheEventIsCancelled("noActivatorRunIfTheEventIsCancelled", "No Activator Run If The Event Is Cancelled", new String[]{"&7&oIf another plugin cancels the event that", "&7&otriggers the activator and you enabled this feature", "&7&othe activator will not be activated"}, null),
    northValue("northValue", "North Value", new String[]{"&7&oThe north value"}, GUI.CLOCK),
    notExecutableItem("notExecutableItem", "Not Executable Item", new String[]{"&7&oIs this item not an executable item?"}, null),
    nutrition("nutrition", "Nutrition", new String[]{"&7The nutrition of the food"}, GUI.CLOCK),
    object("object", "Object", new String[]{"&7&oAn Object"}, Material.PAPER),
    occupiedSlots("occupiedSlots", "Occupied slots", new String[]{"&7&oThe slots that are occupied"}, FixedMaterial.getMaterial(Arrays.asList("CHISELED_BOOKSHELF", "BARRIER"))),
    onlyBreakableWithEI("onlyBreakableWithEI", "Only breakable with EI", new String[]{"&7&oThe list of executable items", "&7&othat can break the block"}, Material.DIAMOND_PICKAXE),
    onlyOwnerBlackListedActivators("onlyOwnerBlackListedActivators", "BlackListed Activators", new String[]{"&7&oBlackListed Activators", "&7&o(can be used by everyone even if", "&7&othe only owner feature is set to true)"}, Material.BARRIER),
    operation("operation", "Operation", new String[]{"&7&oThe operation"}, Material.DISPENSER),
    option("option", "Option", new String[]{"&7&oOption"}, Material.COMPASS),
    oraxenID("oraxenID", "Oraxen", new String[]{"&7&oThe Oraxen ID"}, Material.DIAMOND_BLOCK),
    nexoID("nexoID", "Nexo", new String[]{"&7&oThe Nexo ID"}, Material.DIAMOND_BLOCK),
    otherEICooldowns("otherEICooldowns", "Other EI Cooldowns", new String[]{"&7&oTo add cooldown", "&7&oto another EI"}, Material.ANVIL),
    ownerCommands("ownerCommands", "Owner Commands", new String[]{"&7&oThe owner commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    ownerConditions("ownerConditions", "Owner Conditions", new String[]{""}, Material.ANVIL),
    pages("pages", "Pages", new String[]{"&7&oThe pages"}, GUI.WRITABLE_BOOK),
    part1("part1", "Part 1", new String[]{"&7&oThe first part of the condition"}, GUI.WRITABLE_BOOK),
    part2("part2", "Part 2", new String[]{"&7&oThe second part of the condition"}, GUI.WRITABLE_BOOK),
    particle("particle", "Particle", new String[]{"&7&oA custom particle"}, Material.BLAZE_POWDER),
    particles("particles", "Particles", new String[]{"&7&oThe particles"}, Material.BLAZE_POWDER),
    particlesAmount("particlesAmount", "Particles amount", new String[]{"&7&oThe amount of the particle"}, GUI.COMPARATOR),
    particlesDelay("particlesDelay", "Particles delay", new String[]{"&7&oThe delay of the particle"}, GUI.COMPARATOR),
    particlesDensity("particlesDensity", "Particles density", new String[]{"&7&oThe density of the particle"}, GUI.COMPARATOR),
    particlesOffSet("particlesOffSet", "Particles offset", new String[]{"&7&oThe offset of the particle"}, GUI.COMPARATOR),
    particlesSpeed("particlesSpeed", "Particles speed", new String[]{"&7&oThe speed of the particle"}, GUI.COMPARATOR),
    particlesType("particlesType", "Particles Type", new String[]{"&7&oThe particles type"}, Material.BLAZE_POWDER),
    pattern("pattern", "Pattern", new String[]{"&7&oThe pattern used to trim the armor"}, FixedMaterial.getMaterial(Arrays.asList("EYE_ARMOR_TRIM_SMITHING_TEMPLATE"))),
    patterns("patterns", "Patterns", new String[]{"&7&oThe patterns"}, Material.ANVIL),
    pausePlaceholdersConditions("pausePlaceholdersConditions", "Pause Placeholders Conditions", new String[]{"&7&oThe placeholders conditions to pause the cooldown"}, Material.ANVIL),
    pauseWhenOffline("pauseWhenOffline", "Pause When Offline", new String[]{"&7&oPause the cooldown when the player is offline?"}, null),
    period("period", "Period", new String[]{}, GUI.CLOCK),
    periodInTicks("periodInTicks", "Period in ticks", new String[]{}, GUI.CLOCK),
    pickupStatus("pickupStatus", "Pickup Status", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("LEAD", "LEASH"))),
    pierceLevel("pierceLevel", "Pierce level", new String[]{}, FixedMaterial.getMaterial(Collections.singletonList("TIPPED_ARROW"))),
    placeholderCondition("placeholderCondition", "Placeholder Condition", new String[]{"&7&oA Placeholder condition with its Features"}, GUI.WRITABLE_BOOK),
    placeholderConditionCmds("placeholderConditionCmds", "Console Commands If Invalid", new String[]{"&7&oConsole Commands If Error"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "WRITABLE_BOOK", "BOOK_AND_QUILL"))),
    placeholdersConditions("placeholdersConditions", "Placeholders Conditions", new String[]{"&7&oThe placeholders conditions"}, Material.ANVIL),
    playerCanSit("playerCanSit", "Player Can Sit", new String[]{"&7&oPlayer can sit"}, FixedMaterial.getMaterial(Arrays.asList("STONE_STAIRS"))),
    playerCommands("playerCommands", "Player Commands", new String[]{"&7&oThe player commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    playerSettings("playerSettings", "Player Settings", new String[]{"&7&oThe player settings"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    playerConditions("playerConditions", "Player Conditions", new String[]{"&7&oAdd player conditions to determine", "&7&owhen the "}, Material.ANVIL),
    playerCooldownFeatures("playerCooldownFeatures", "Player Cooldown Features", new String[]{"&7&oThe player cooldown"}, GUI.CLOCK),
    potionColor("potionColor", "Potion Color", new String[]{"&7&oThe potion color"}, Material.REDSTONE),
    potionEffect("potionEffect", "Potion Effect", new String[]{"&7&oA potion effect with its Features"}, FixedMaterial.getBrewingStand()),
    potionEffectType("potionEffectType", "Potion Effect Type", new String[]{"&7&oThe type of the potion effect"}, Material.COMPASS),
    potionEffects("potionEffects", "Potion Effects", new String[]{"&7&oThe potion effects"}, FixedMaterial.getBrewingStand()),
    potionExtended("potionExtended", "Potion extended", new String[]{"&7&oPotion extended"}, null),
    potionFeatures("potionFeatures", "Potion Settings", new String[]{"&7&oThe potion settings"}, FixedMaterial.getBrewingStand()),
    potionType("potionType", "Potion Type", new String[]{"&7&oThe potion type"}, Material.POTION),
    potionUpgraded("potionUpgraded", "Potion upgraded", new String[]{"&7&oPotion upgraded"}, null),
    radius("radius", "Radius", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("HEART_OF_THE_SEA", "WEB"))),
    rarity("rarity", "Rarity", new String[]{"&7&oThe rarity of the item"}, Material.EMERALD),
    recognitions("recognitions", "Recognitions", new String[]{"&7&oRecognitions of the item"}, Material.PAPER),
    redstoneColor("redstoneColor", "Redstone Color", new String[]{"&7&oThe redstone color"}, Material.REDSTONE),
    refreshTag("refreshTagDoNotEdit", "Refresh Tags", new String[]{"&7&oRefresh tags"}, null),
    removeWhenHitBlock("removeWhenHitBlock", "Remove when hit block", new String[]{"&7&oRemove when hit block"}, null),
    repairCost("repairCost", "Repair Cost", new String[]{"&7&oThe repair cost"}, GUI.CLOCK),
    repairableFeatures("repairableFeatures", "Repairable Features", new String[]{"&7&oThe repairable features"}, Material.ANVIL),
    requiredExecutableItem("requiredExecutableItem", "Required Executable Item", new String[]{"&7&oA required ExecutableItem"}, Material.PAPER),
    requiredExecutableItems("requiredExecutableItems", "Required Executable Items", new String[]{"&7&oThe required executable items"}, Material.DIAMOND_PICKAXE),
    requiredExperience("requiredExperience", "Required Experience", new String[]{"&7&oRequired experience"}, FixedMaterial.getMaterial(Arrays.asList("EXPERIENCE_BOTTLE", "EXP_BOTTLE"))),
    requiredGroups("requiredGroups", "Required Things", new String[]{"&7&oRequired things"}, Material.ANVIL),
    requiredItem("requiredItem", "Required Item", new String[]{"&7&oA required item"}, Material.PAPER),
    requiredItems("requiredItems", "Required Items", new String[]{"&7&oThe required items"}, Material.DIAMOND),
    requiredLevel("requiredLevel", "Required Level", new String[]{"&7&oRequired level"}, FixedMaterial.getMaterial(Arrays.asList("EXPERIENCE_BOTTLE", "EXP_BOTTLE"))),
    requiredMagic("requiredMagic", "Required Magic", new String[]{"&7&oA required Magic", "&7&o(from EcoSkills)"}, GUI.WRITABLE_BOOK),
    requiredMagics("requiredMagics", "Required Magics", new String[]{"&7&oThe required Magics", "&7&o(from EcoSkills)"}, GUI.WRITABLE_BOOK),
    requiredMana("requiredMana", "Required Mana", new String[]{"&7&oRequired mana", "&4&lRequire: &6AureliumSkills/MMOCore"}, Material.WATER_BUCKET),
    requiredMoney("requiredMoney", "Required Money", new String[]{"&7&oRequired money", "&4&lRequire: &6Vault"}, Material.GOLD_BLOCK),
    requiredObject("requiredObject", "Required Object", new String[]{}, Material.COMPASS),
    resetInternalDatasWhenBroken("resetInternalDatasWhenBroken", "Reset internal datas when broken", new String[]{"&7&oIf the block is broken,", "&7&oit will reset the internal datas", "&7&o(Usage, and variables)"}, Material.LEVER),
    restrictions("restrictions", "Restrictions", new String[]{"&7&oThe restrictions features"}, Material.ANVIL),
    rotation("rotation", "Rotation", new String[]{"&7&oRotation of the lever"}, GUI.CLOCK),
    saturation("saturation", "Saturation", new String[]{"&7The saturation of the food"}, GUI.CLOCK),
    scale("scale", "Scale", new String[]{""}, Material.HOPPER),
    scheduleFeatures("scheduleFeatures", "Schedule Features", new String[]{"&7&oSchedule Features"}, GUI.CLOCK),
    silenceOutput("silenceOutput", "Silence Output", new String[]{"&7&oSilence the output of the command", "&7&o(Only in the console)"}, null),
    silent("silent", "Silent", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("BELL", "JUKEBOW"))),
    sitFeatures("sitFeatures", "Sit Features", new String[]{"&7&oSit Features"}, FixedMaterial.getMaterial(Arrays.asList("STONE_STAIRS"))),
    skyLight("skyLight", "Sky Light", new String[]{""}, FixedMaterial.getMaterial(Arrays.asList("LIGHT"))),
    slot("slot", "Slot", new String[]{"&7&oThe slot"}, Material.ARMOR_STAND),
    sound("sound", "Sound", new String[]{"&7&oThe sound"}, Material.NOTE_BLOCK),
    southValue("southValue", "South Value", new String[]{"&7&oThe south value"}, GUI.CLOCK),
    spawnerType("spawnerType", "Spawner type", new String[]{"&7&oThe type of the spawner"}, FixedMaterial.getMaterial(Arrays.asList("SPAWNER"))),
    spawnerFeatures("spawnerFeatures", "Spawner Features", new String[]{"&7&oSpawner Features"}, FixedMaterial.getMaterial(Arrays.asList("SPAWNER"))),
    spawnDelay("spawnDelay", "Spawn Delay", new String[]{"&7&oThe spawn delay"}, GUI.CLOCK),
    spawnRange("spawnRange", "Spawn Range", new String[]{"&7&oThe spawn range"}, GUI.CLOCK),
    minSpawnDelay("minSpawnDelay", "Min Spawn Delay", new String[]{"&7&oThe min spawn delay"}, GUI.CLOCK),
    maxSpawnDelay("maxSpawnDelay", "Max Spawn Delay", new String[]{"&7&oThe max spawn delay"}, GUI.CLOCK),
    spawnCount("spawnCount", "Spawn Count", new String[]{"&7&oThe spawn count"}, GUI.CLOCK),
    requiredPlayerRange("requiredPlayerRange", "Required Player Range", new String[]{"&7&oThe required player range"}, GUI.CLOCK),
    maxNearbyEntities("maxNearbyEntities", "Max Nearby Entities", new String[]{"&7&oThe max nearby entities"}, GUI.CLOCK),
    potentialSpawns("potentialSpawns", "Potential Spawns", new String[]{"&7&oThe potential spawns"}, Material.ANVIL),
    addSpawnerNbtToItem("addSpawnerNbtToItem", "Add Spawner NBT To Item", new String[]{"&7&oAdd the spawner NBT to the item", "&cA Minecraft Warning will appear in the lore"}, null),
    startDate("startDate", "Start Date", new String[]{"&7&oThe start date"}, GUI.CLOCK),
    stopCheckingOtherConditionsIfNotValid("stopCheckingOtherConditionsIfNotValid", "Stop checking other conditions if not valid", new String[]{"&7&oStop checking other conditions", "&7&oif the condition is not valid"}, GUI.WRITABLE_BOOK),
    storageFeatures("storageFeatures", "Storage Features", new String[]{"&7&oStorage Features"}, FixedMaterial.getMaterial(Arrays.asList("CHEST"))),
    storeItemInfo("storeItemInfo", "Store item info", new String[]{"&7&oStore item info ?", "&7&oStore the item info like the owner"}, null),
    string("string", "String", new String[]{"&7&oA string"}, Material.PAPER),
    subPattern("subPattern", "Sub Pattern", new String[]{"&7&oA sub pattern with its Features"}, Material.ANVIL),
    subPatterns("subPatterns", "Sub Patterns", new String[]{"&7&oThe sub patterns"}, Material.ANVIL),
    swappable("swappable", "Swappable", new String[]{"&7&oThe item can be swapped"}, null),
    tags("tags", "Tags", new String[]{"&7&oThe tags", "&8&oExamples", "&a{age:3}", "&a{lit:true}", "&7&ominecraft.fandom.com/wiki/Block_states"}, GUI.WRITABLE_BOOK),
    targetBlockCommands("targetBlockCommands", "Target Block Commands", new String[]{"&7&oThe target block commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    targetBlockConditions("targetBlockConditions", "Target Block Conditions", new String[]{""}, Material.ANVIL),
    targetItemCommands("targetItemCommands", "Target Item Commands", new String[]{"&7&oThe target item commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    targetCommands("targetCommands", "Target Commands", new String[]{"&7&oThe target commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    targetConditions("targetConditions", "Target Conditions", new String[]{""}, Material.ANVIL),
    targetEntityCommands("targetEntityCommands", "Target Entity Commands", new String[]{"&7&oThe target entity commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    targetEntityConditions("targetEntityConditions", "Target Entity Conditions", new String[]{""}, Material.ANVIL),
    targetPlayerCommands("targetPlayerCommands", "Target Player Commands", new String[]{"&7&oThe target player commands to execute"}, FixedMaterial.getMaterial(Arrays.asList("COMMAND_BLOCK", "COMMAND"))),
    targetPlayerConditions("targetPlayerConditions", "Target Player Conditions", new String[]{""}, Material.ANVIL),
    title("title", "Title", new String[]{"&7&oThe title"}, Material.NAME_TAG),
    titleAdjustment("titleAdjustment", "Title Adjustment", new String[]{"&7&oTitle Adjustment"}, FixedMaterial.getMaterial(Collections.singletonList("PISTON"))),
    titleFeatures("titleFeatures", "Title Features", new String[]{"&7&oThe title features"}, Material.ANVIL),
    to("to", "To", new String[]{""}, GUI.CLOCK),
    toolRule("toolRule", "Tool Rule", new String[]{"&7&oThe tool rule"}, Material.DIAMOND_PICKAXE),
    toolRules("toolRules", "Tool Rules", new String[]{"&7&oThe tool rules"}, Material.DIAMOND_PICKAXE),
    tooltipModel("tooltipModel", "Tooltip Model", new String[]{"&7&oThe tooltip model", "&7&oFormat: namespace:id", "&7&oWill reference model /assets/<namespace>/textures/gui/sprites/tooltip/<id>_background", "&7&oWill reference model /assets/<namespace>/textures/gui/sprites/tooltip/<id>_frame"}, FixedMaterial.getMaterial(Arrays.asList("BLUE_GLAZED_TERRACOTTA"))),
    trimMaterial("trimMaterial", "Trim Material", new String[]{"&7&oThe material used to trim the armor"}, Material.DIAMOND),
    type("type", "Type", new String[]{"&7&oThe type"}, GUI.COMPARATOR),
    typeTarget("typeTarget", "Type Target", new String[]{"&7&oType target"}, Material.COMPASS),
    unbreakable("unbreakable", "Unbreakable", new String[]{"&7&oItem unbreakable ?"}, Material.BEDROCK),
    underValue("underValue", "Under Value", new String[]{"&7&oThe under value"}, GUI.CLOCK),
    updateArmorSettings("updateArmorSettings", "Update Armor Settings", new String[]{"&7&oUpdate the armor settings of the item"}, null),
    updateAttributes("updateAttributes", "Update Attributes", new String[]{"&7&oUpdate the attributes of the item"}, null),
    updateCustomModelData("updateCustomModelData", "Update Custom Model Data", new String[]{"&7&oUpdate the custom model data of the item"}, null),
    updateDurability("updateDurability", "Update Durability", new String[]{"&7&oUpdate the durability of the item"}, null),
    updateEnchants("updateEnchants", "Update Enchants", new String[]{"&7&oUpdate the enchants of the item"}, null),
    updateHiders("updateHiders", "Update Hiders", new String[]{"&7&oUpdate the hide flags of the item"}, null),
    updateEquippable("updateEquippable", "Update Equippable", new String[]{"&7&oUpdate the equippable features of the item"}, null),
    updateLore("updateLore", "Update Lore", new String[]{"&7&oUpdate the lore of the item"}, null),
    updateMaterial("updateMaterial", "Update Material", new String[]{"&7&oUpdate the material of the item"}, null),
    updateName("updateName", "Update Name", new String[]{"&7&oUpdate the name of the item"}, null),
    usage("usage", "Usage", new String[]{"&7&oThe usage of the item", "&a-1 &7&o= Infinite", "&aIncrease &7&oor &cDecrease &7&othis usage with", "&eUsageModification &7&oin your activators"}, Material.BUCKET),
    usageConditions("usageConditions", "Usage Conditions", new String[]{"&7&oThe usage condition"}, GUI.CLOCK),
    usageFeatures("usageFeatures", "Usage Features", new String[]{"&7&oThe usage features", "&aIncrease &7&oor &cDecrease &7&othis usage with", "&eUsageModification &7&oin your activators"}, Material.BUCKET),
    usageLimit("usageLimit", "Usage limit", new String[]{"&7&oThe usage limit of the item", "&7&oUsage can't be increased above this value"}, Material.BUCKET),
    usageModification("usageModification", "Usage Modification", new String[]{"&7&oUsage modification"}, Material.BUCKET),
    useCooldownFeatures("useCooldownFeatures", "Use Cooldown Features", new String[]{"&7&oThe use cooldown features"}, GUI.CLOCK),
    usePerDay("usePerDay", "Use per day", new String[]{"&7&oThe use per day features"}, Material.BUCKET),
    uuid("uuid", "UUID", new String[]{"&7&oThe UUID"}, Material.NAME_TAG),
    vanillaUseCooldown("vanillaUseCooldown", "Vanilla Use Cooldown", new String[]{"&7&oThe vanilla use cooldown"}, GUI.CLOCK),
    variable("variable", "Variable", new String[]{"&7&oA variable with its Features"}, GUI.WRITABLE_BOOK),
    variableName("variableName", "Variable Name", new String[]{"&7&oThe variable name", "&7&othat you want create/modify"}, GUI.WRITABLE_BOOK),
    variableUpdate("variableUpdate", "Variable Update", new String[]{"&7&oA variable update with its Features"}, GUI.WRITABLE_BOOK),
    variables("variables", "Variables", new String[]{"&7&oThe variables", "&7&oVariables are used to store data like kills / deaths ..."}, GUI.WRITABLE_BOOK),
    variablesModification("variablesModification", "Variables modifications", new String[]{"&7&oPart to modifiy your variables"}, GUI.WRITABLE_BOOK),
    velocity("velocity", "Velocity", new String[]{}, FixedMaterial.getMaterial(Arrays.asList("FIREWORK_ROCKET", "ELYTRA"))),
    viewDistanceFurniture("viewDistanceFurniture", "View Distance Furniture", new String[]{"&7&oThe view distance furniture"}, GUI.CLOCK),
    viewRange("viewRange", "View Range", new String[]{"&7&oThe view range"}, GUI.CLOCK),
    visualFire("visualFire", "Visual Fire", new String[]{}, Material.FLINT_AND_STEEL),
    visualItem("visualItem", "Visual Item", new String[]{""}, Material.ITEM_FRAME),
    westValue("westValue", "West Value", new String[]{"&7&oThe west value"}, GUI.CLOCK),
    when("when", "When", new String[]{"&7&oWhen the feature is activated"}, GUI.CLOCK),
    whitelistMaterials("whitelistMaterials", "Whitelist materials", new String[]{"&7&oWhitelist materials", "&7&oPut the materials", "&7&othat can be put in the container"}, Material.CHEST),
    whitelistedWorlds("whitelistedWorlds", "Whitelisted worlds", new String[]{"&7&oThe whitelisted worlds features"}, FixedMaterial.getMaterial(Arrays.asList("GRASS_BLOCK", "GRASS"))),
    width("width", "Width", new String[]{"&7&oMaintain F3 + b to see the zone"}, GUI.CLOCK),
    worldConditions("worldConditions", "World Conditions", new String[]{""}, Material.ANVIL),

    recipesList("recipesList", "Recipes List", new String[]{"&7&oThe recipes list"}, Material.ANVIL),
    typeOfCraftingTableRecipe("typeOfCraftingTableRecipe", "Type Of Crafting Table Recipe", new String[]{"&7&oThe type of crafting table recipe"}, FixedMaterial.getMaterial(Arrays.asList("CRAFTING_TABLE", "WORKBENCH"))),
    cookingTime("cookingTime", "Cooking Time", new String[]{"&7&oThe cooking time"}, GUI.CLOCK),
    experience("experience", "Experience", new String[]{"&7&oThe experience"}, GUI.CLOCK),
    result("result", "Result", new String[]{"&7&oThe result"}, Material.ANVIL),
    recipeType("recipeType", "Recipe Type", new String[]{"&7&oThe recipe type"}, Material.ANVIL),
    ;


    private String configName;
    private String editorName;
    private String[] editorDescription;
    private Material editorMaterial;
    private boolean requirePremium;
    private SavingVerbosityLevel savingVerbosityLevel;

    FeatureSettingsSCoreEN(String name, String editorName, String[] editorDescription, Material editorMaterial) {
        this.configName = "";
        this.editorName = editorName;
        this.editorDescription = editorDescription;
        this.editorMaterial = editorMaterial;
        this.requirePremium = false;
        this.savingVerbosityLevel = SavingVerbosityLevel.SAVE_ALWAYS;
    }

    @Override
    public String getIdentifier() {
        return this.name();
    }

    @Override
    public String getName() {
        return configName;
    }

    @Override
    public void setName(String name) {
        this.configName = name;
    }

    @Override
    public String getEditorName() {
        return editorName;
    }

    @Override
    public String[] getEditorDescription() {
        return editorDescription;
    }

    @Override
    public String[] getEditorDescriptionBrut() {
        return editorDescription;
    }

    @Override
    public Material getEditorMaterial() {
        return editorMaterial;
    }

    @Override
    public boolean isRequirePremium() {
        return requirePremium;
    }

    @Override
    public void setRequirePremium(boolean requirePremium) {
        this.requirePremium = requirePremium;
    }

    @Override
    public SavingVerbosityLevel getSavingVerbosityLevel() {
        return savingVerbosityLevel;
    }

    @Override
    public void setSavingVerbosityLevel(SavingVerbosityLevel savingVerbosityLevel) {
        this.savingVerbosityLevel = savingVerbosityLevel;
    }
}
