class="kw">package com.hypixel.hytale.server.core.command.system.arguments.types;

class="kw">import com.hypixel.hytale.component.Ref;
class="kw">import com.hypixel.hytale.math.vector.Rotation3f;
class="kw">import com.hypixel.hytale.math.vector.Rotation3fc;
class="kw">import com.hypixel.hytale.protocol.GameMode;
class="kw">import com.hypixel.hytale.protocol.SoundCategory;
class="kw">import com.hypixel.hytale.server.core.Message;
class="kw">import com.hypixel.hytale.server.core.NameMatching;
class="kw">import com.hypixel.hytale.server.core.asset.type.ambiencefx.config.AmbienceFX;
class="kw">import com.hypixel.hytale.server.core.asset.type.audiostate.config.AudioState;
class="kw">import com.hypixel.hytale.server.core.asset.type.blocktype.config.BlockType;
class="kw">import com.hypixel.hytale.server.core.asset.type.entityeffect.config.EntityEffect;
class="kw">import com.hypixel.hytale.server.core.asset.type.environment.config.Environment;
class="kw">import com.hypixel.hytale.server.core.asset.type.item.config.Item;
class="kw">import com.hypixel.hytale.server.core.asset.type.model.config.ModelAsset;
class="kw">import com.hypixel.hytale.server.core.asset.type.musiccontainer.config.MusicContainer;
class="kw">import com.hypixel.hytale.server.core.asset.type.particle.config.ParticleSystem;
class="kw">import com.hypixel.hytale.server.core.asset.type.soundevent.config.SoundEvent;
class="kw">import com.hypixel.hytale.server.core.asset.type.weather.config.Weather;
class="kw">import com.hypixel.hytale.server.core.auth.AuthCredentialStoreProvider;
class="kw">import com.hypixel.hytale.server.core.auth.ProfileServiceClient;
class="kw">import com.hypixel.hytale.server.core.auth.ServerAuthManager;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandContext;
class="kw">import com.hypixel.hytale.server.core.command.system.CommandSender;
class="kw">import com.hypixel.hytale.server.core.command.system.ParseResult;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.ArgWrapper;
class="kw">import com.hypixel.hytale.server.core.command.system.arguments.system.Argument;
class="kw">import com.hypixel.hytale.server.core.command.system.exceptions.GeneralCommandException;
class="kw">import com.hypixel.hytale.server.core.command.system.suggestion.SuggestionResult;
class="kw">import com.hypixel.hytale.server.core.command.system.suggestion.SuggestionUtil;
class="kw">import com.hypixel.hytale.server.core.modules.entity.hitboxcollision.HitboxCollisionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.entity.repulsion.RepulsionConfig;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.Interaction;
class="kw">import com.hypixel.hytale.server.core.modules.interaction.interaction.config.RootInteraction;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockFilter;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockMask;
class="kw">import com.hypixel.hytale.server.core.prefab.selection.mask.BlockPattern;
class="kw">import com.hypixel.hytale.server.core.universe.PlayerRef;
class="kw">import com.hypixel.hytale.server.core.universe.Universe;
class="kw">import com.hypixel.hytale.server.core.universe.world.World;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.EntityStore;
class="kw">import com.hypixel.hytale.server.core.universe.world.storage.provider.IChunkStorageProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldgen.provider.IWorldGenProvider;
class="kw">import com.hypixel.hytale.server.core.universe.world.worldmap.provider.IWorldMapProvider;
class="kw">import it.unimi.dsi.fastutil.Pair;
class="kw">import it.unimi.dsi.fastutil.objects.ObjectArrayList;
class="kw">import java.util.Collection;
class="kw">import java.util.Iterator;
class="kw">import java.util.List;
class="kw">import java.util.Locale;
class="kw">import java.util.Set;
class="kw">import java.util.UUID;
class="kw">import java.util.concurrent.CompletableFuture;
class="kw">import java.util.function.BiFunction;
class="kw">import java.util.function.Function;
class="kw">import javax.annotation.Nonnull;
class="kw">import javax.annotation.Nullable;
class="kw">import org.joml.Vector2i;
class="kw">import org.joml.Vector3d;
class="kw">import org.joml.Vector3i;

class="kw">public class="kw">final class ArgTypes {
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Boolean> BOOLEAN = new SingleArgumentType<Boolean>(
      "server.commands.parsing.argtype.boolean.name", "server.commands.parsing.argtype.boolean.usage", "true", "false"
   ) {
      class="kw">private class="kw">static class="kw">final String TRUE_STRING = "true";
      class="kw">private class="kw">static class="kw">final String FALSE_STRING = "false";

      @Nonnull
      class="kw">public Boolean parse(String var1, ParseResult var2) {
         class="kw">return Boolean.parseBoolean(var1);
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         var2 = var2.toLowerCase(Locale.ROOT);
         if ("false".startsWith(var2)) {
            var4.suggest("false");
            var4.suggest("true");
         } else {
            var4.suggest("true");
            var4.suggest("false");
         }
      }

      @Override
      class="kw">public int getSuggestionValueCount() {
         class="kw">return 2;
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Integer> INTEGER = new SingleArgumentType<Integer>(
      "server.commands.parsing.argtype.integer.name", "server.commands.parsing.argtype.integer.usage", "-27432", "-1", "0", "1", "56346"
   ) {
      @Nullable
      class="kw">public Integer parse(@Nonnull String var1, ParseResult var2) {
         try {
            class="kw">return Integer.parseInt(var1);
         } catch (NumberFormatException var4) {
            var2.fail(Message.translation("server.commands.parsing.argtype.integer.fail").param("input", var1));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> STRING = new SingleArgumentType<String>(
      "server.commands.parsing.argtype.string.name",
      "server.commands.parsing.argtype.string.usage",
      "\"Hytale is really cool!\"",
      "\"Numbers work 2!\"",
      "\"If you can type it...\""
   ) {
      class="kw">public String parse(String var1, ParseResult var2) {
         class="kw">return var1;
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> GREEDY_STRING = new SingleArgumentType<String>(
      "server.commands.parsing.argtype.greedystring.name",
      "server.commands.parsing.argtype.greedystring.usage",
      "Hello world!",
      "Let's go everyone",
      "This is a multi-word sentence."
   ) {
      class="kw">public String parse(String var1, ParseResult var2) {
         class="kw">return var1;
      }

      @Override
      class="kw">public boolean isGreedyString() {
         class="kw">return true;
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Float> FLOAT = new SingleArgumentType<Float>(
      "server.commands.parsing.argtype.float.name", "server.commands.parsing.argtype.float.usage", "3.14159", "-2.5", "7"
   ) {
      @Nullable
      class="kw">public Float parse(@Nonnull String var1, ParseResult var2) {
         try {
            class="kw">return Float.parseFloat(var1);
         } catch (NumberFormatException var4) {
            var2.fail(Message.translation("server.commands.parsing.argtype.float.fail").param("input", var1));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Double> DOUBLE = new SingleArgumentType<Double>(
      "server.commands.parsing.argtype.double.name", "server.commands.parsing.argtype.double.usage", "-3.14", "0.0", "3.141596"
   ) {
      @Nullable
      class="kw">public Double parse(@Nonnull String var1, ParseResult var2) {
         try {
            class="kw">return Double.parseDouble(var1);
         } catch (NumberFormatException var4) {
            var2.fail(Message.translation("server.commands.parsing.argtype.double.fail").param("input", var1));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<UUID> UUID = new SingleArgumentType<UUID>(
      "server.commands.parsing.argtype.uuid.name", "server.commands.parsing.argtype.uuid.usage", java.util.UUID.randomUUID().toString()
   ) {
      @Nullable
      class="kw">public UUID parse(@Nonnull String var1, ParseResult var2) {
         try {
            class="kw">return java.util.UUID.fromString(var1);
         } catch (IllegalArgumentException var4) {
            var2.fail(Message.translation("server.commands.parsing.argtype.uuid.fail").param("input", var1));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<UUID> PLAYER_UUID = new SingleArgumentType<UUID>(
      "server.commands.parsing.argtype.playerUuid.name",
      "server.commands.parsing.argtype.playerUuid.usage",
      java.util.UUID.randomUUID().toString(),
      "john_doe",
      "user123"
   ) {
      @Nullable
      class="kw">public UUID parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         try {
            class="kw">return java.util.UUID.fromString(var1);
         } catch (IllegalArgumentException var7) {
            for (World var4 : Universe.get().getWorlds().values()) {
               Collection var5 = var4.getPlayerRefs();
               PlayerRef var6 = NameMatching.DEFAULT.find(var5, var1, PlayerRef::getUsername);
               if (var6 != null) {
                  class="kw">return var6.getUuid();
               }
            }

            var2.fail(Message.translation("server.commands.parsing.argtype.playerUuid.fail").param("input", var1));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<CompletableFuture<ProfileServiceClient.PublicGameProfile>> GAME_PROFILE_LOOKUP_ASYNC = new SingleArgumentType<CompletableFuture<ProfileServiceClient.PublicGameProfile>>(
      "server.commands.parsing.argtype.playerUuidLookup.name",
      "server.commands.parsing.argtype.playerUuidLookup.usage",
      java.util.UUID.randomUUID().toString(),
      "john_doe",
      "user123"
   ) {
      @Nullable
      class="kw">public CompletableFuture<ProfileServiceClient.PublicGameProfile> parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         for (World var4 : Universe.get().getWorlds().values()) {
            Collection var5 = var4.getPlayerRefs();
            PlayerRef var6 = NameMatching.DEFAULT.find(var5, var1, PlayerRef::getUsername);
            if (var6 != null) {
               class="kw">return CompletableFuture.completedFuture(new ProfileServiceClient.PublicGameProfile(var6.getUuid(), var6.getUsername()));
            }
         }

         UUID var9 = null;

         try {
            var9 = java.util.UUID.fromString(var1);
         } catch (IllegalArgumentException var8) {
         }

         ServerAuthManager var10 = ServerAuthManager.getInstance();
         String var11 = var10.getSessionToken();
         if (var11 == null) {
            class="kw">return CompletableFuture.failedFuture(new IllegalStateException("No session token available for profile lookup"));
         }

         ProfileServiceClient var12 = var10.getProfileServiceClient();
         CompletableFuture var7;
         if (var9 != null) {
            var7 = var12.getProfileByUuidAsync(var9, var11);
         } else {
            var7 = var12.getProfileByUsernameAsync(var1, var11);
         }

         class="kw">return var7.thenApply(var1x -> {
            if (var1x != null && var1x.getUuid() != null) {
               class="kw">return (ProfileServiceClient.PublicGameProfile)var1x;
            } else {
               throw new IllegalArgumentException("Player not found: " + var1);
            }
         });
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<ProfileServiceClient.PublicGameProfile> GAME_PROFILE_LOOKUP = new SingleArgumentType<ProfileServiceClient.PublicGameProfile>(
      "server.commands.parsing.argtype.playerUuidLookup.name",
      "server.commands.parsing.argtype.playerUuidLookup.usage",
      java.util.UUID.randomUUID().toString(),
      "john_doe",
      "user123"
   ) {
      @Nullable
      class="kw">public ProfileServiceClient.PublicGameProfile parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         try {
            class="kw">return ArgTypes.GAME_PROFILE_LOOKUP_ASYNC.parse(var1, var2).join();
         } catch (Exception var5) {
            Throwable var4 = var5.getCause() != null ? var5.getCause() : var5;
            if (var4 class="kw">instanceof IllegalStateException) {
               var2.fail(Message.translation("server.commands.parsing.argtype.playerUuidLookup.noAuth").param("input", var1));
            } else if (var4 class="kw">instanceof IllegalArgumentException) {
               var2.fail(Message.translation("server.commands.parsing.argtype.playerUuidLookup.notFound").param("input", var1));
            } else {
               var2.fail(
                  Message.translation("server.commands.parsing.argtype.playerUuidLookup.lookupError")
                     .param("input", var1)
                     .param("error", var4.getMessage() != null ? var4.getMessage() : var4.getClass().getSimpleName())
               );
            }

            class="kw">return null;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         ArgTypes.suggestOnlinePlayers(var1, var2, var4);
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Coord> RELATIVE_DOUBLE_COORD = new SingleArgumentType<Coord>(
      "server.commands.parsing.argtype.doubleCoordinate.name", "server.commands.parsing.argtype.doubleCoordinate.usage", "5.0", "~-2.3", "0.0"
   ) {
      @Nullable
      class="kw">public Coord parse(@Nonnull String var1, ParseResult var2) {
         try {
            class="kw">return Coord.parse(var1);
         } catch (NumberFormatException var4) {
            var2.fail(Message.translation("server.commands.parsing.argtype.doubleCoordinate.fail").param("input", var1));
            class="kw">return null;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         if (var2.isEmpty() || var2.startsWith("~")) {
            var4.suggest("~");
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<IntCoord> RELATIVE_INT_COORD = (new SingleArgumentType<IntCoord>(
         "server.commands.parsing.argtype.integerCoordinate.name", "server.commands.parsing.argtype.integerCoordinate.usage", "5", "~-2", "0"
      ) {
         @Nullable
         class="kw">public IntCoord parse(@Nonnull String var1, ParseResult var2) {
            try {
               class="kw">return IntCoord.parse(var1);
            } catch (NumberFormatException var4) {
               var2.fail(Message.translation("server.commands.parsing.argtype.integerCoordinate.fail").param("input", var1));
               class="kw">return null;
            }
         }

         @Override
         class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
            if (var2.isEmpty() || var2.startsWith("~")) {
               var4.suggest("~");
            }
         }
      })
      .withSharedSuggestions(RELATIVE_DOUBLE_COORD);
   class="kw">public class="kw">static class="kw">final SingleArgumentType<RelativeInteger> RELATIVE_INTEGER = new SingleArgumentType<RelativeInteger>(
      "Relative Integer", "A tilde to mark an integer as relative to a base", "5", "~-2", "0"
   ) {
      @Nullable
      class="kw">public RelativeInteger parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         class="kw">return RelativeInteger.parse(var1, var2);
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<RelativeFloat> RELATIVE_FLOAT = (new SingleArgumentType<RelativeFloat>(
         "server.commands.parsing.argtype.relativeFloat.name", "server.commands.parsing.argtype.relativeFloat.usage", "90.0", "~-45.5", "~"
      ) {
         @Nullable
         class="kw">public RelativeFloat parse(@Nonnull String var1, @Nonnull ParseResult var2) {
            class="kw">return RelativeFloat.parse(var1, var2);
         }

         @Override
         class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
            if (var2.isEmpty() || var2.startsWith("~")) {
               var4.suggest("~");
            }
         }
      })
      .withSharedSuggestions(RELATIVE_DOUBLE_COORD);
   class="kw">public class="kw">static class="kw">final SingleArgumentType<PlayerRef> PLAYER_REF = (new SingleArgumentType<PlayerRef>(
         "server.commands.parsing.argtype.player.name", "server.commands.parsing.argtype.player.usage", "john_doe", "user123"
      ) {
         @Nullable
         class="kw">public PlayerRef parse(@Nonnull String var1, @Nonnull ParseResult var2) {
            PlayerRef var3 = null;

            for (World var5 : Universe.get().getWorlds().values()) {
               Collection var6 = var5.getPlayerRefs();
               var3 = NameMatching.DEFAULT.find(var6, var1, PlayerRef::getUsername);
               if (var3 != null) {
                  break;
               }
            }

            if (var3 == null) {
               var2.fail(Message.translation("server.commands.errors.noSuchPlayer").param("username", var1));
               class="kw">return null;
            } else {
               class="kw">return var3;
            }
         }

         @Override
         class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
            ArgTypes.suggestOnlinePlayers(var1, var2, var4);
         }

         @Nonnull
         class="kw">public PlayerRef processedGet(CommandSender var1, @Nonnull CommandContext var2, Argument<?, PlayerRef> var3) {
            PlayerRef var4 = var2.get(var3);
            if (var4 != null) {
               class="kw">return var4;
            } else if (var1 class="kw">instanceof PlayerRef var5) {
               class="kw">return var5;
            } else {
               throw new GeneralCommandException(Message.translation("server.commands.errors.playerOrArg").param("option", "player"));
            }
         }
      })
      .withSharedSuggestions(GAME_PROFILE_LOOKUP);
   class="kw">public class="kw">static class="kw">final SingleArgumentType<World> WORLD = new SingleArgumentType<World>(
      "server.commands.parsing.argtype.world.name", "server.commands.parsing.argtype.world.usage", "class="kw">default"
   ) {
      @Nullable
      class="kw">public World parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         World var3 = Universe.get().getWorld(var1);
         if (var3 == null) {
            var2.fail(Message.translation("server.commands.errors.noSuchWorld").param("name", var1));
            class="kw">return null;
         } else {
            class="kw">return var3;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         String var5 = var2.toLowerCase(Locale.ROOT);

         for (World var7 : Universe.get().getWorlds().values()) {
            String var8 = var7.getName();
            if (var8 != null && var8.toLowerCase(Locale.ROOT).startsWith(var5)) {
               var4.suggest(var8);
            }
         }
      }

      @Nullable
      class="kw">public World processedGet(CommandSender var1, @Nonnull CommandContext var2, @Nonnull Argument<?, World> var3) {
         World var4 = var3.get(var2);
         if (var4 != null) {
            class="kw">return var4;
         }

         Universe var5 = Universe.get();
         if (var2.isPlayer()) {
            Ref var6 = var2.senderAsPlayerRef();
            if (var6 != null && var6.isValid()) {
               class="kw">return var6.getStore().getExternalData().getWorld();
            }
         }

         if (var5.getWorlds().size() == 1) {
            Iterator var7 = var5.getWorlds().values().iterator();
            if (var7.hasNext()) {
               class="kw">return var7.next();
            }
         }

         throw new GeneralCommandException(Message.translation("server.commands.errors.playerOrArg").param("option", "world"));
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<ModelAsset> MODEL_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.model.name", ModelAsset.class, "server.commands.parsing.argtype.asset.model.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Weather> WEATHER_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.weather.name", Weather.class, "server.commands.parsing.argtype.asset.weather.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Interaction> INTERACTION_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.interaction.name", Interaction.class, "server.commands.parsing.argtype.asset.interaction.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<RootInteraction> ROOT_INTERACTION_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.rootinteraction.name", RootInteraction.class, "server.commands.parsing.argtype.asset.interaction.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<EntityEffect> EFFECT_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.effect.name", EntityEffect.class, "server.commands.parsing.argtype.asset.effect.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Environment> ENVIRONMENT_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.environment.name", Environment.class, "server.commands.parsing.argtype.asset.environment.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Item> ITEM_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.item.name", Item.class, "server.commands.parsing.argtype.asset.item.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<BlockType> BLOCK_TYPE_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.blocktype.name", BlockType.class, "server.commands.parsing.argtype.asset.blocktype.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<ParticleSystem> PARTICLE_SYSTEM = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.particlesystem.name", ParticleSystem.class, "server.commands.parsing.argtype.asset.particlesystem.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<HitboxCollisionConfig> HITBOX_COLLISION_CONFIG = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.hitboxcollisionconfig.name",
      HitboxCollisionConfig.class,
      "server.commands.parsing.argtype.asset.hitboxcollisionconfig.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<RepulsionConfig> REPULSION_CONFIG = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.repulsionconfig.name", RepulsionConfig.class, "server.commands.parsing.argtype.asset.repulsionconfig.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<SoundEvent> SOUND_EVENT_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.soundevent.name", SoundEvent.class, "server.commands.parsing.argtype.asset.soundevent.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<AmbienceFX> AMBIENCE_FX_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.ambiencefx.name", AmbienceFX.class, "server.commands.parsing.argtype.asset.ambiencefx.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<MusicContainer> MUSIC_CONTAINER_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.musiccontainer.name", MusicContainer.class, "server.commands.parsing.argtype.asset.musiccontainer.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<AudioState> AUDIO_STATE_ASSET = new AssetArgumentType(
      "server.commands.parsing.argtype.asset.audiostate.name", AudioState.class, "server.commands.parsing.argtype.asset.audiostate.usage"
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<SoundCategory> SOUND_CATEGORY = forEnum("server.commands.parsing.argtype.soundcategory.name", SoundCategory.class);
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> WORLD_GEN_PROVIDER_KEY = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.worldgenprovider.name", "server.commands.parsing.argtype.worldgenprovider.usage", IWorldGenProvider.CODEC
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> WORLD_MAP_PROVIDER_KEY = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.worldmapprovider.name", "server.commands.parsing.argtype.worldmapprovider.usage", IWorldMapProvider.CODEC
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> CHUNK_STORAGE_PROVIDER_KEY = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.chunkstorageprovider.name", "server.commands.parsing.argtype.chunkstorageprovider.usage", IChunkStorageProvider.CODEC
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> AUTH_STORE_PROVIDER_KEY = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.authstoreprovider.name", "server.commands.parsing.argtype.authstoreprovider.usage", AuthCredentialStoreProvider.CODEC
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> WORLD_GEN_PROVIDER_KEY_OR_DEFAULT = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.worldgenprovider.name",
      "server.commands.parsing.argtype.worldgenprovider.usage",
      IWorldGenProvider.CODEC,
      Set.of("class="kw">default")
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> CHUNK_STORAGE_PROVIDER_KEY_OR_DEFAULT = new CodecKeyArgumentType(
      "server.commands.parsing.argtype.chunkstorageprovider.name",
      "server.commands.parsing.argtype.chunkstorageprovider.usage",
      IChunkStorageProvider.CODEC,
      Set.of("class="kw">default")
   );
   class="kw">public class="kw">static class="kw">final ArgWrapper<EntityWrappedArg, UUID> ENTITY_ID = new ArgWrapper<>(
      UUID.withOverriddenUsage("server.commands.parsing.argtype.entityid.usage"), EntityWrappedArg::new
   );
   class="kw">public class="kw">static class="kw">final SingleArgumentType<ArgTypes.IntegerComparisonOperator> INTEGER_COMPARISON_OPERATOR = new SingleArgumentType<ArgTypes.IntegerComparisonOperator>(
      "Integer Comparison Operator", "A mathematical sign for integer comparison", ">", "<", ">=", "<=", "%", "=", "!="
   ) {
      @Nullable
      class="kw">public ArgTypes.IntegerComparisonOperator parse(String var1, @Nonnull ParseResult var2) {
         ArgTypes.IntegerComparisonOperator var3 = ArgTypes.IntegerComparisonOperator.getFromStringRepresentation(var1);
         if (var3 == null) {
            var2.fail(Message.raw("Could not find an integer comparison operator for value: '" + var1 + "'."));
            class="kw">return null;
         } else {
            class="kw">return var3;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<ArgTypes.IntegerOperation> INTEGER_OPERATION = new SingleArgumentType<ArgTypes.IntegerOperation>(
      "Integer Operator", "A mathematical sign for performing an operation", "+", "-", "*", "/", "%", "="
   ) {
      @Nullable
      class="kw">public ArgTypes.IntegerOperation parse(String var1, @Nonnull ParseResult var2) {
         ArgTypes.IntegerOperation var3 = ArgTypes.IntegerOperation.getFromStringRepresentation(var1);
         if (var3 == null) {
            var2.fail(Message.raw("Could not find an integer operator for value: '" + var1 + "'."));
            class="kw">return null;
         } else {
            class="kw">return var3;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Pair<Integer, Integer>> INT_RANGE = new MultiArgumentType<Pair<Integer, Integer>>(
      "Integer Range", "Two integers representing a minimum and maximum of a range", "-2 8", "5 5", "1 5"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Integer> minValue = this.withParameter(
         "min", "Minimum value, must be less than or equal to max value", ArgTypes.INTEGER
      );
      class="kw">private class="kw">final WrappedArgumentType<Integer> maxValue = this.withParameter(
         "max", "Maximum value, must be greater than or equal to min value", ArgTypes.INTEGER
      );

      @Nullable
      class="kw">public Pair<Integer, Integer> parse(@Nonnull MultiArgumentContext var1, @Nonnull ParseResult var2) {
         if (var1.get(this.minValue) > var1.get(this.maxValue)) {
            var2.fail(
               Message.raw(
                  "You cannot set the minimum value as larger than the maximum value. Min: " + var1.get(this.minValue) + " Max: " + var1.get(this.maxValue)
               )
            );
            class="kw">return null;
         } else {
            class="kw">return Pair.of(var1.get(this.minValue), var1.get(this.maxValue));
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<RelativeIntegerRange> RELATIVE_INT_RANGE = new MultiArgumentType<RelativeIntegerRange>(
      "Integer Range", "Two integers representing a minimum and maximum of a range", "~-2 ~8", "~5 ~5", "~1 ~5"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<RelativeInteger> minValue = this.withParameter(
         "min", "Minimum value, must be less than or equal to max value", ArgTypes.RELATIVE_INTEGER
      );
      class="kw">private class="kw">final WrappedArgumentType<RelativeInteger> maxValue = this.withParameter(
         "max", "Maximum value, must be greater than or equal to min value", ArgTypes.RELATIVE_INTEGER
      );

      @Nullable
      class="kw">public RelativeIntegerRange parse(@Nonnull MultiArgumentContext var1, @Nonnull ParseResult var2) {
         RelativeInteger var3 = this.minValue.get(var1);
         RelativeInteger var4 = this.maxValue.get(var1);
         if (var3 != null && var4 != null) {
            if (var3.isRelative() != var4.isRelative()) {
               var2.fail(Message.raw("Your range must have both min and max as relative, or both as not relative. You can not mix relatives in ranges."));
               class="kw">return null;
            } else if (var3.getRawValue() > var4.getRawValue()) {
               var2.fail(
                  Message.raw(
                     "You cannot set the minimum value as larger than the maximum value. Min: " + var1.get(this.minValue) + " Max: " + var1.get(this.maxValue)
                  )
               );
               class="kw">return null;
            } else {
               class="kw">return new RelativeIntegerRange(var1.get(this.minValue), var1.get(this.maxValue));
            }
         } else {
            var2.fail(Message.raw("Could not parse min or max value of the range."));
            class="kw">return null;
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Vector2i> VECTOR2I = new MultiArgumentType<Vector2i>(
      "Integer Vector 2D", "Two integers, generally corresponding to x/z axis", "124 232", "5 -3", "1 1"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Integer> xValue = this.withParameter("x", "X value", ArgTypes.INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<Integer> zValue = this.withParameter("z", "Z value", ArgTypes.INTEGER);

      @Nonnull
      class="kw">public Vector2i parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new Vector2i(var1.get(this.xValue), var1.get(this.zValue));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Vector3i> VECTOR3I = new MultiArgumentType<Vector3i>(
      "Integer Vector", "Three integers, generally corresponding to x/y/z axis", "124 232 234", "5 0 -3", "1 1 1"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Integer> xValue = this.withParameter("x", "X value", ArgTypes.INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<Integer> yValue = this.withParameter("y", "Y value", ArgTypes.INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<Integer> zValue = this.withParameter("z", "Z value", ArgTypes.INTEGER);

      @Nonnull
      class="kw">public Vector3i parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new Vector3i(var1.get(this.xValue), var1.get(this.yValue), var1.get(this.zValue));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<RelativeVector3i> RELATIVE_VECTOR3I = new MultiArgumentType<RelativeVector3i>(
      "Relative Integer Vector", "Three optionally relative integers, generally corresponding to x/y/z axis", "124 ~232 234", "~5 0 ~-3", "1 ~1 1"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<RelativeInteger> xValue = this.withParameter("x", "X value", ArgTypes.RELATIVE_INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<RelativeInteger> yValue = this.withParameter("y", "Y value", ArgTypes.RELATIVE_INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<RelativeInteger> zValue = this.withParameter("z", "Z value", ArgTypes.RELATIVE_INTEGER);

      @Nonnull
      class="kw">public RelativeVector3i parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new RelativeVector3i(var1.get(this.xValue), var1.get(this.yValue), var1.get(this.zValue));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<RelativeIntPosition> RELATIVE_BLOCK_POSITION = new MultiArgumentType<RelativeIntPosition>(
      "server.commands.parsing.argtype.relativeBlockPosition.name",
      "server.commands.parsing.argtype.relativeBlockPosition.usage",
      "124 232 234",
      "~5 ~ ~-3",
      "~ ~ ~"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<IntCoord> xValue = this.withParameter("x", "server.commands.parsing.argtype.xCoord.usage", ArgTypes.RELATIVE_INT_COORD);
      class="kw">private class="kw">final WrappedArgumentType<IntCoord> yValue = this.withParameter("y", "server.commands.parsing.argtype.yCoord.usage", ArgTypes.RELATIVE_INT_COORD);
      class="kw">private class="kw">final WrappedArgumentType<IntCoord> zValue = this.withParameter("z", "server.commands.parsing.argtype.zCoord.usage", ArgTypes.RELATIVE_INT_COORD);

      @Nonnull
      class="kw">public RelativeIntPosition parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new RelativeIntPosition(var1.get(this.xValue), var1.get(this.yValue), var1.get(this.zValue));
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         ArgTypes.suggestPosition(var1, var2, var4, "~ ~ ~", var0 -> (int)Math.floor(var0.x) + " " + (int)Math.floor(var0.y) + " " + (int)Math.floor(var0.z));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<RelativeDoublePosition> RELATIVE_POSITION = new MultiArgumentType<RelativeDoublePosition>(
      "server.commands.parsing.argtype.relativePosition.name",
      "server.commands.parsing.argtype.relativePosition.usage",
      "124.63 232.27 234.22",
      "~5.5 ~ ~",
      "~ ~ ~"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Coord> xValue = this.withParameter("x", "server.commands.parsing.argtype.xCoord.usage", ArgTypes.RELATIVE_DOUBLE_COORD);
      class="kw">private class="kw">final WrappedArgumentType<Coord> yValue = this.withParameter("y", "server.commands.parsing.argtype.yCoord.usage", ArgTypes.RELATIVE_DOUBLE_COORD);
      class="kw">private class="kw">final WrappedArgumentType<Coord> zValue = this.withParameter("z", "server.commands.parsing.argtype.zCoord.usage", ArgTypes.RELATIVE_DOUBLE_COORD);

      @Nonnull
      class="kw">public RelativeDoublePosition parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new RelativeDoublePosition(var1.get(this.xValue), var1.get(this.yValue), var1.get(this.zValue));
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         ArgTypes.suggestPosition(var1, var2, var4, "~ ~ ~", var0 -> String.format("%.2f %.2f %.2f", var0.x, var0.y, var0.z));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<RelativeChunkPosition> RELATIVE_CHUNK_POSITION = new MultiArgumentType<RelativeChunkPosition>(
      "server.commands.parsing.argtype.relativeChunkPosition.name", "server.commands.parsing.argtype.relativeChunkPosition.usage", "5 10", "~c2 ~c-3", "~ ~"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<IntCoord> xValue = this.withParameter("x", "server.commands.parsing.argtype.xCoord.usage", ArgTypes.RELATIVE_INT_COORD);
      class="kw">private class="kw">final WrappedArgumentType<IntCoord> zValue = this.withParameter("z", "server.commands.parsing.argtype.zCoord.usage", ArgTypes.RELATIVE_INT_COORD);

      @Nonnull
      class="kw">public RelativeChunkPosition parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new RelativeChunkPosition(var1.get(this.xValue), var1.get(this.zValue));
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         ArgTypes.suggestPosition(var1, var2, var4, "~ ~", var0 -> ((int)Math.floor(var0.x) >> 5) + " " + ((int)Math.floor(var0.z) >> 5));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Rotation3fc> ROTATION = new MultiArgumentType<Rotation3fc>(
      "server.commands.parsing.argtype.rotation.name", "server.commands.parsing.argtype.rotation.usage", "124.63 232.27 234.22"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Float> pitch = this.withParameter(
         "server.commands.parsing.argtype.pitch.name", "server.commands.parsing.argtype.pitch.usage", ArgTypes.FLOAT
      );
      class="kw">private class="kw">final WrappedArgumentType<Float> yaw = this.withParameter(
         "server.commands.parsing.argtype.yaw.name", "server.commands.parsing.argtype.yaw.usage", ArgTypes.FLOAT
      );
      class="kw">private class="kw">final WrappedArgumentType<Float> roll = this.withParameter(
         "server.commands.parsing.argtype.roll.name", "server.commands.parsing.argtype.roll.usage", ArgTypes.FLOAT
      );

      @Nonnull
      class="kw">public Rotation3fc parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return new Rotation3f(var1.get(this.pitch), var1.get(this.yaw), var1.get(this.roll));
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<String> BLOCK_TYPE_KEY = new SingleArgumentType<String>("Block Type Key", "A block type", "Wood_Drywood_Planks_Half") {
      @Nullable
      class="kw">public String parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         try {
            class="kw">return var1;
         } catch (Exception var4) {
            var2.fail(Message.raw(var4.getMessage()));
            class="kw">return null;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         ArgTypes.suggestBlockTypeKeys(var2, "", var4);
      }

      @Override
      class="kw">public int getSuggestionValueCount() {
         class="kw">return BlockType.getAssetMap().getAssetMap().size();
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Integer> BLOCK_ID = new ProcessedArgumentType<String, Integer>(
      "Block Id", Message.raw("A block type, converted to an int id"), BLOCK_TYPE_KEY, "Wood_Drywood_Planks_Half"
   ) {
      @Nonnull
      class="kw">public Integer processInput(String var1) {
         class="kw">return BlockType.getAssetMap().getIndex(var1);
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Integer> COLOR = new SingleArgumentType<Integer>(
      "server.commands.parsing.argtype.color.name", "server.commands.parsing.argtype.color.usage", "#FF0000", "#00FF00FF", "16711680", "0xFF0000"
   ) {
      @Nullable
      class="kw">public Integer parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         var1 = var1.trim();
         if (var1.isEmpty()) {
            var2.fail(Message.raw("Color cannot be empty"));
            class="kw">return null;
         }

         if (var1.charAt(0) == '#') {
            try {
               String var3 = var1.substring(1);
               long var4 = Long.parseLong(var3, 16);
               class="kw">switch (var3.length()) {
                  case 3:
                     int var6 = (int)(var4 >> 8 & 15L);
                     int var7 = (int)(var4 >> 4 & 15L);
                     int var8 = (int)(var4 & 15L);
                     class="kw">return 0xFF000000 | var6 << 20 | var6 << 16 | var7 << 12 | var7 << 8 | var8 << 4 | var8;
                  case 4:
                     int var9 = (int)(var4 >> 12 & 15L);
                     int var10 = (int)(var4 >> 8 & 15L);
                     int var11 = (int)(var4 >> 4 & 15L);
                     int var12 = (int)(var4 & 15L);
                     class="kw">return var9 << 28 | var9 << 24 | var10 << 20 | var10 << 16 | var11 << 12 | var11 << 8 | var12 << 4 | var12;
                  case 5:
                  case 7:
                  class="kw">default:
                     var2.fail(Message.raw("Invalid hex color format. Expected #RGB, #RGBA, #RRGGBB, or #RRGGBBAA, got: '" + var1 + "'"));
                     class="kw">return null;
                  case 6:
                     class="kw">return 0xFF000000 | (int)var4;
                  case 8:
                     class="kw">return (int)var4;
               }
            } catch (NumberFormatException var13) {
               var2.fail(Message.raw("Invalid hex color: '" + var1 + "'. " + var13.getMessage()));
               class="kw">return null;
            }
         } else if (var1.length() <= 2 || !var1.startsWith("0x") && !var1.startsWith("0X")) {
            try {
               class="kw">return Integer.parseInt(var1);
            } catch (NumberFormatException var15) {
               var2.fail(
                  Message.raw("Invalid color format. Expected hex color (#RRGGBB), hex integer (0xFF0000), or decimal integer (16711680), got: '" + var1 + "'")
               );
               class="kw">return null;
            }
         } else {
            try {
               class="kw">return Integer.parseUnsignedInt(var1.substring(2), 16);
            } catch (NumberFormatException var14) {
               var2.fail(Message.raw("Invalid hex integer color: '" + var1 + "'. " + var14.getMessage()));
               class="kw">return null;
            }
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Pair<Integer, String>> LAYER_ENTRY_TYPE = new MultiArgumentType<Pair<Integer, String>>(
      "Layer Entry Type", "A thickness for a corresponding block pattern", "1 Rock_Stone", "3 50%Rock_Basalt;50%Rock_Stone"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Integer> thickness = this.withParameter("thickness", "How thick the layer should be", ArgTypes.INTEGER);
      class="kw">private class="kw">final WrappedArgumentType<String> blockPattern = this.withParameter(
         "blockPattern", "The block pattern to use for the layer. If using with percentages, separate values with a ';'", ArgTypes.STRING
      );

      @Nonnull
      class="kw">public Pair<Integer, String> parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return Pair.of(var1.get(this.thickness), var1.get(this.blockPattern));
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<Pair<Integer, String>> WEIGHTED_BLOCK_TYPE = new MultiArgumentType<Pair<Integer, String>>(
      "Weighted Block Type", "A weight corresponding to a blocktype", "5 Empty", "20 Rock_Stone", "2 Rock_Shale"
   ) {
      class="kw">private class="kw">final WrappedArgumentType<Integer> weight = this.withParameter(
         "weight", "The relative weight of this entry. Think of it as a lottery ticket", ArgTypes.INTEGER
      );
      class="kw">private class="kw">final WrappedArgumentType<String> blockType = this.withParameter(
         "blockType", "The BlockTypeKey associated with the weight", ArgTypes.BLOCK_TYPE_KEY
      );

      @Nonnull
      class="kw">public Pair<Integer, String> parse(@Nonnull MultiArgumentContext var1, ParseResult var2) {
         class="kw">return Pair.of(var1.get(this.weight), var1.get(this.blockType));
      }
   };
   class="kw">private class="kw">static class="kw">final ArgumentType<String> WEIGHTED_BLOCK_ENTRY = new SingleArgumentType<String>(
      "Weighted Block Entry", "A block with optional weight prefix (e.g., 20%Rock_Stone or Rock_Stone)", "Rock_Stone", "20%Rock_Stone", "50%Rock_Stone|Yaw=90"
   ) {
      @Nullable
      class="kw">public String parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         if (var1.isEmpty()) {
            var2.fail(Message.raw("Block entry cannot be empty"));
            class="kw">return null;
         }

         String var3 = var1;
         int var4 = var3.indexOf(37);
         if (var4 != -1) {
            var3 = var3.substring(var4 + 1);
         }

         int var5 = var3.indexOf(124);
         if (var5 != -1) {
            var3 = var3.substring(0, var5);
         }

         int var6 = BlockType.getAssetMap().getIndex(var3);
         if (var6 == Integer.MIN_VALUE) {
            var2.fail(Message.translation("server.builderTools.invalidBlockType").param("name", "").param("key", var3));
            class="kw">return null;
         } else {
            class="kw">return var1;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         int var5 = var2.indexOf(37);
         if (var5 >= 0) {
            String var6 = var2.substring(0, var5 + 1);
            String var7 = var2.substring(var5 + 1);
            int var8 = var7.indexOf(124);
            if (var8 < 0) {
               ArgTypes.suggestBlockTypeKeys(var7, var6, var4);
               if (!var7.isEmpty() && ArgTypes.isExactBlockTypeKey(var7)) {
                  var4.suggestContinuation(var2 + ",");
               }
            }
         } else if (!var2.isEmpty() && Character.isDigit(var2.charAt(0)) && var2.chars().allMatch(var0 -> Character.isDigit((char)var0) || var0 == 46)) {
            var4.suggestContinuation(var2 + "%");
         } else {
            ArgTypes.suggestBlockTypeKeys(var2, "", var4);
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<BlockPattern> BLOCK_PATTERN = new ProcessedArgumentType<List<String>, BlockPattern>(
      "Block Pattern",
      Message.raw("A list of blocks with optional weights (e.g., [20%Rock_Stone, 80%Rock_Shale])"),
      new ListArgumentType<>(WEIGHTED_BLOCK_ENTRY),
      "[Rock_Stone]",
      "[20%Rock_Stone, 80%Rock_Shale]",
      "[50%Rock_Stone|Yaw=90, 50%Fluid_Water]"
   ) {
      @Nonnull
      class="kw">public BlockPattern processInput(@Nonnull List<String> var1) {
         String var2 = String.join(",", var1);
         class="kw">return BlockPattern.parse(var2);
      }
   };
   class="kw">private class="kw">static class="kw">final String[] MASK_PREFIXES = new String[]{"!", ">", "<", "~", "^", "#", "+n", "+e", "+s", "+w", "%xy", "%xz", "%zy"};
   class="kw">private class="kw">static class="kw">final String[] MASK_INVERT_PREFIXES = new String[]{"!>", "!<", "!~", "!^", "!#", "!+n", "!+e", "!+s", "!+w", "!%xy", "!%xz", "!%zy"};
   class="kw">private class="kw">static class="kw">final ArgumentType<BlockMask> INDIVIDUAL_BLOCK_MASK = new SingleArgumentType<BlockMask>(
      "Block Mask", "Create a block mask using symbols and block names", ">Grass_Full", "!Fluid_Water", "!^Fluid_Lava", "!#"
   ) {
      @Nullable
      class="kw">public BlockMask parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         try {
            BlockMask var3 = BlockMask.parse(var1);
            if (var3.hasInvalidBlocks()) {
               BlockFilter.ParsedFilterParts var4 = BlockFilter.parseComponents(var1);
               var2.fail(Message.translation("server.builderTools.invalidBlockType").param("key", var4.blocks()));
               class="kw">return null;
            } else {
               class="kw">return var3;
            }
         } catch (Exception var5) {
            var2.fail(Message.raw("There was an error in the parsing of your block mask: " + var1 + ", please try again."));
            class="kw">return null;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         if (var2.isEmpty()) {
            for (String var20 : ArgTypes.MASK_PREFIXES) {
               var4.suggest(var20);
            }
         } else if ("!".equals(var2)) {
            for (String var19 : ArgTypes.MASK_INVERT_PREFIXES) {
               var4.suggest(var19);
            }

            ArgTypes.suggestBlockTypeKeys(var2, "!", var4);
         } else {
            String var5 = var2;
            String var6 = "";

            for (String var10 : ArgTypes.MASK_INVERT_PREFIXES) {
               if (var5.startsWith(var10)) {
                  var6 = var10;
                  var5 = var5.substring(var10.length());
                  break;
               }
            }

            if (var6.isEmpty()) {
               for (String var22 : ArgTypes.MASK_PREFIXES) {
                  if (!var22.equals("#") && var5.startsWith(var22)) {
                     var6 = var22;
                     var5 = var5.substring(var22.length());
                     break;
                  }
               }
            }

            ArgTypes.suggestBlockTypeKeys(var5, var6, var4);
         }
      }
   };
   class="kw">public class="kw">static class="kw">final ArgumentType<BlockMask> BLOCK_MASK = new ProcessedArgumentType<List<BlockMask>, BlockMask>(
      "Block Mask",
      Message.raw("A list of block masks that combine together"),
      new ListArgumentType<>(INDIVIDUAL_BLOCK_MASK),
      "[!Fluid_Water, !^Fluid_Lava]",
      "[>Grass_Full, !#]"
   ) {
      class="kw">public BlockMask processInput(@Nonnull List<BlockMask> var1) {
         class="kw">return BlockMask.combine(var1.toArray(BlockMask[]::new));
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<Integer> TICK_RATE = new SingleArgumentType<Integer>(
      "server.commands.parsing.argtype.tickrate.name", "server.commands.parsing.argtype.tickrate.usage", "30tps", "33ms", "60", "20tps", "50ms"
   ) {
      @Nullable
      class="kw">public Integer parse(@Nonnull String var1, @Nonnull ParseResult var2) {
         String var3 = var1.trim().toLowerCase(Locale.ROOT);
         if (var3.isEmpty()) {
            var2.fail(Message.translation("server.commands.parsing.argtype.tickrate.empty"));
            class="kw">return null;
         }

         try {
            if (var3.endsWith("tps")) {
               String var8 = var3.substring(0, var3.length() - 3).trim();
               class="kw">return Integer.parseInt(var8);
            }

            if (var3.endsWith("ms")) {
               String var4 = var3.substring(0, var3.length() - 2).trim();
               double var5 = Double.parseDouble(var4);
               if (var5 <= 0.0) {
                  var2.fail(Message.translation("server.commands.parsing.argtype.tickrate.invalidMs").param("input", var1));
                  class="kw">return null;
               } else {
                  class="kw">return (int)Math.round(1000.0 / var5);
               }
            } else {
               class="kw">return Integer.parseInt(var3);
            }
         } catch (NumberFormatException var7) {
            var2.fail(Message.translation("server.commands.parsing.argtype.tickrate.fail").param("input", var1));
            class="kw">return null;
         }
      }

      @Override
      class="kw">public void suggest(@Nonnull CommandSender var1, @Nonnull String var2, int var3, @Nonnull SuggestionResult var4) {
         var4.suggest("30tps");
         var4.suggest("60tps");
         var4.suggest("20tps");
         var4.suggest("33ms");
         var4.suggest("16ms");
         var4.suggest("50ms");
      }
   };
   class="kw">public class="kw">static class="kw">final SingleArgumentType<GameMode> GAME_MODE = new GameModeArgumentType();

   class="kw">public ArgTypes() {
   }

   @Nonnull
   class="kw">public class="kw">static <E class="kw">extends Enum<E>> SingleArgumentType<E> forEnum(String var0, @Nonnull Class<E> var1) {
      class="kw">return new EnumArgumentType<>(var0, var1);
   }

   class="kw">private class="kw">static boolean isExactBlockTypeKey(@Nonnull String var0) {
      for (String var2 : BlockType.getAssetMap().getAssetMap().keySet()) {
         if (var2.toString().equalsIgnoreCase(var0)) {
            class="kw">return true;
         }
      }

      class="kw">return false;
   }

   class="kw">private class="kw">static void suggestBlockTypeKeys(@Nonnull String var0, @Nonnull String var1, @Nonnull SuggestionResult var2) {
      Set var3 = BlockType.getAssetMap().getAssetMap().keySet();
      List var4 = new ObjectArrayList(var3.size());

      for (String var6 : var3) {
         var4.add(var6.toString());
      }

      SuggestionUtil.suggestFiltered(var4, var0, var1x -> var1 + var1x, var2);
   }

   class="kw">private class="kw">static void suggestOnlinePlayers(@Nonnull CommandSender var0, @Nonnull String var1, @Nonnull SuggestionResult var2) {
      String var3 = var1.toLowerCase(Locale.ROOT);

      for (World var5 : Universe.get().getWorlds().values()) {
         for (PlayerRef var7 : var5.getPlayerRefs()) {
            String var8 = var7.getUsername();
            if (var8 != null && var8.toLowerCase(Locale.ROOT).startsWith(var3)) {
               var2.suggest(var8);
            }
         }
      }
   }

   class="kw">private class="kw">static void suggestPosition(
      @Nonnull CommandSender var0, @Nonnull String var1, @Nonnull SuggestionResult var2, @Nonnull String var3, @Nonnull Function<Vector3d, String> var4
   ) {
      if (var1.isEmpty() || var1.startsWith("~")) {
         var2.suggest(var3);
      }

      if (var0 class="kw">instanceof PlayerRef var5) {
         Vector3d var6 = var5.getTransform().getPosition();
         var2.suggest(var4.apply(var6));
      }
   }

   class="kw">public enum IntegerComparisonOperator {
      GREATER_THAN((var0, var1) -> var0 > var1, ">"),
      GREATER_THAN_EQUAL_TO((var0, var1) -> var0 >= var1, ">="),
      LESS_THAN((var0, var1) -> var0 < var1, "<"),
      LESS_THAN_EQUAL_TO((var0, var1) -> var0 <= var1, "<="),
      MOD_EQUAL_ZERO((var0, var1) -> var0 % var1 == 0, "%"),
      MOD_NOT_EQUAL_ZERO((var0, var1) -> var0 % var1 != 0, "!%"),
      EQUAL_TO(Integer::equals, "="),
      NOT_EQUAL_TO((var0, var1) -> !var0.equals(var1), "!=");

      class="kw">private class="kw">final BiFunction<Integer, Integer, Boolean> comparisonFunction;
      class="kw">private class="kw">final String stringRepresentation;

      IntegerComparisonOperator(BiFunction<Integer, Integer, Boolean> nullxx, String nullxxx) {
         this.comparisonFunction = nullxx;
         this.stringRepresentation = nullxxx;
      }

      class="kw">public boolean compare(int var1, int var2) {
         class="kw">return this.comparisonFunction.apply(var1, var2);
      }

      class="kw">public String getStringRepresentation() {
         class="kw">return this.stringRepresentation;
      }

      @Nullable
      class="kw">public class="kw">static ArgTypes.IntegerComparisonOperator getFromStringRepresentation(String var0) {
         for (ArgTypes.IntegerComparisonOperator var4 : values()) {
            if (var4.stringRepresentation.equals(var0)) {
               class="kw">return var4;
            }
         }

         class="kw">return null;
      }
   }

   class="kw">public enum IntegerOperation {
      ADD(Integer::sum, "+"),
      SUBTRACT((var0, var1) -> var0 - var1, "-"),
      MULTIPLY((var0, var1) -> var0 * var1, "*"),
      DIVIDE((var0, var1) -> var0 / var1, "/"),
      MODULUS((var0, var1) -> var0 % var1, "%"),
      SET((var0, var1) -> var1, "=");

      @Nonnull
      class="kw">private class="kw">final BiFunction<Integer, Integer, Integer> operationFunction;
      @Nonnull
      class="kw">private class="kw">final String stringRepresentation;

      IntegerOperation(@Nonnull class="kw">final BiFunction<Integer, Integer, Integer> nullxx, @Nonnull class="kw">final String nullxxx) {
         this.operationFunction = nullxx;
         this.stringRepresentation = nullxxx;
      }

      class="kw">public int operate(int var1, int var2) {
         class="kw">return this.operationFunction.apply(var1, var2);
      }

      class="kw">public String getStringRepresentation() {
         class="kw">return this.stringRepresentation;
      }

      @Nullable
      class="kw">public class="kw">static ArgTypes.IntegerOperation getFromStringRepresentation(@Nonnull String var0) {
         for (ArgTypes.IntegerOperation var4 : values()) {
            if (var4.stringRepresentation.equals(var0)) {
               class="kw">return var4;
            }
         }

         class="kw">return null;
      }
   }
}