AAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAAA

2 files changed, 123 insertions, 4 deletions

diff --git a/azalea-brigadier/src/builder/argument_builder.rs b/azalea-brigadier/src/builder/argument_builder.rs
index 8a64a9e4..19706a22 100644
--- a/azalea-brigadier/src/builder/argument_builder.rs
+++ b/azalea-brigadier/src/builder/argument_builder.rs
@@ -10,7 +10,7 @@ where
     T: ArgumentBuilder<S, T>,
 {
     arguments: RootCommandNode<S>,
-    command: dyn Command<S>,
+    command: Option<dyn Command<S>>,
     requirement: dyn Fn(&S) -> bool,
     target: Option<dyn CommandNode<S>>,
     modifier: Option<dyn RedirectModifier<S>>,
@@ -18,7 +18,6 @@ where
 }
 
 pub trait ArgumentBuilder<S, T> {
-    fn this() -> T;
     fn build(self) -> dyn CommandNode<S>;
 }
 
@@ -92,11 +91,11 @@ where
         Ok(self)
     }
 
-    pub fn redirect(&self) -> Option<&dyn CommandNode<S>> {
+    pub fn get_redirect(&self) -> Option<&dyn CommandNode<S>> {
         self.target.as_ref()
     }
 
-    pub fn redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
+    pub fn get_redirect_modifier(&self) -> Option<&dyn RedirectModifier<S>> {
         self.modifier.as_ref()
     }
 
diff --git a/azalea-brigadier/src/builder/required_argument_builder.rs b/azalea-brigadier/src/builder/required_argument_builder.rs
index e69de29b..3ec613c4 100644
--- a/azalea-brigadier/src/builder/required_argument_builder.rs
+++ b/azalea-brigadier/src/builder/required_argument_builder.rs
@@ -0,0 +1,120 @@
+use crate::{
+    arguments::argument_type::ArgumentType,
+    suggestion::suggestion_provider::SuggestionProvider,
+    tree::{argument_command_node::ArgumentCommandNode, command_node::BaseCommandNode},
+};
+
+use super::argument_builder::BaseArgumentBuilder;
+
+// private RequiredArgumentBuilder(final String name, final ArgumentType<T> type) {
+// 	this.name = name;
+// 	this.type = type;
+// }
+
+// public static <S, T> RequiredArgumentBuilder<S, T> argument(final String name, final ArgumentType<T> type) {
+// 	return new RequiredArgumentBuilder<>(name, type);
+// }
+
+// public RequiredArgumentBuilder<S, T> suggests(final SuggestionProvider<S> provider) {
+// 	this.suggestionsProvider = provider;
+// 	return getThis();
+// }
+
+// public SuggestionProvider<S> getSuggestionsProvider() {
+// 	return suggestionsProvider;
+// }
+
+// @Override
+// protected RequiredArgumentBuilder<S, T> getThis() {
+// 	return this;
+// }
+
+// public ArgumentType<T> getType() {
+// 	return type;
+// }
+
+// public String getName() {
+// 	return name;
+// }
+
+// public ArgumentCommandNode<S, T> build() {
+// 	final ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
+
+// 	for (final CommandNode<S> argument : getArguments()) {
+// 		result.addChild(argument);
+// 	}
+
+// 	return result;
+// }
+
+pub struct RequiredArgumentBuilder<S, T> {
+    // private final String name;
+    // private final ArgumentType<T> type;
+    // private SuggestionProvider<S> suggestionsProvider = null;
+    name: String,
+    type_: dyn ArgumentType<T>,
+    suggestions_provider: Option<dyn SuggestionProvider<S>>,
+
+    pub base: BaseArgumentBuilder<S, T>,
+}
+
+impl<S, T> RequiredArgumentBuilder<S, T> {
+    pub fn new(name: String, type_: dyn ArgumentType<T>) -> Self {
+        Self {
+            name,
+            type_,
+            suggestions_provider: None,
+            base: BaseArgumentBuilder::new(name, type_),
+        }
+    }
+
+    pub fn argument(name: String, type_: dyn ArgumentType<T>) -> Self {
+        Self::new(name, type_)
+    }
+
+    pub fn suggests(mut self, provider: dyn SuggestionProvider<S>) -> Self {
+        self.suggestions_provider = Some(provider);
+        self
+    }
+
+    pub fn suggestions_provider(&self) -> Option<&dyn SuggestionProvider<S>> {
+        self.suggestions_provider.as_ref()
+    }
+
+    pub fn get_type(&self) -> &dyn ArgumentType<T> {
+        &self.type_
+    }
+
+    pub fn name(&self) -> &str {
+        &self.name
+    }
+
+    // final ArgumentCommandNode<S, T> result = new ArgumentCommandNode<>(getName(), getType(), getCommand(), getRequirement(), getRedirect(), getRedirectModifier(), isFork(), getSuggestionsProvider());
+
+    // for (final CommandNode<S> argument : getArguments()) {
+    // 	result.addChild(argument);
+    // }
+
+    // return result;
+    pub fn build(self) -> ArgumentCommandNode<S, T> {
+        let result = ArgumentCommandNode {
+            name: self.name,
+            type_: &self.type_,
+            base: BaseCommandNode {
+                command: self.base.command,
+                requirement: self.base.requirement,
+                redirect: self.base.redirect,
+                modifier: self.base.modifier,
+                forks: self.base.forks,
+                ..BaseCommandNode::default()
+            },
+            custom_suggestions: self.base.custom_suggestions,
+        };
+
+        for argument in self.base.arguments {
+            result.add_child(argument);
+        }
+
+        result
+    }
+}