Apply suggestions from code review

Co-authored-by: Matouš Kučera <mk@kcra.me>

Author: Strokkur424

docs/paper/dev/api/command-api/basics/custom-arguments.mdx

@@ -55,13 +55,13 @@ public final class OppedPlayerArgument implements CustomArgumentType<Player, Pla
     @Override
     public <S> Player parse(StringReader reader, S source) throws CommandSyntaxException {
         if (!(source instanceof CommandSourceStack stack)) {
-            final Message message = MessageComponentSerializer.message().serialize(text("The source needs to be a CommandSourceStack!"));
+            final Message message = MessageComponentSerializer.message().serialize(Component.text("The source needs to be a CommandSourceStack!"));
             throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
         }
 
         final Player player = getNativeType().parse(reader).resolve(stack).getFirst();
         if (!player.isOp()) {
-            final Message message = MessageComponentSerializer.message().serialize(text(player.getName() + " is not a server operator!"));
+            final Message message = MessageComponentSerializer.message().serialize(Component.text(player.getName() + " is not a server operator!"));
             throw new CommandSyntaxException(new SimpleCommandExceptionType(message), message);
         }
 
@@ -100,7 +100,7 @@ Commands.argument("player", new OppedPlayerArgument())
     })
 ```
 
-This is way more readable and easy to understand than without custom argument. And it is reusable! Hopefully, you now have a basic grasp of **why** you should use custom arguments.
+This is way more readable and easy to understand when using a custom argument. And it is reusable! Hopefully, you now have a basic grasp of **why** you should use custom arguments.
 
 ## Examining the `CustomArgumentType` interface
 The interface is declared as follows:
@@ -136,18 +136,18 @@ public interface CustomArgumentType<T, N> extends ArgumentType<T> {
 
 ### Generic types
 There are three generic types present in the interface:
-- `T`: This is the type of the class that is returned when `CommandContext#getArgument` is called on this argument
-- `N`: The native type of the class which this custom argument extends. Used as the "underlying" argument
+- `T`: This is the type of the class that is returned when `CommandContext#getArgument` is called on this argument.
+- `N`: The native type of the class which this custom argument extends. Used as the "underlying" argument.
 - `S`: A generic type for the command source. Will usually be a `CommandSourceStack`.
 
 ### Methods
 | Method declaration                                                                                                              | Description  |
 |---------------------------------------------------------------------------------------------------------------------------------|--------------|
-| `ArgumentType<N> getNativeType()`                                                                                               |  Here, you declare the underlying argument type which is used as a base for clientside argument validation                                                                                             |
-| `T parse(final StringReader reader) throws CommandSyntaxException`                                                              |  This method is used if `T parse(StringReader, S)` was not overwritten. In here you can run conversion and validation logic.                                                                             |
-| `default <S> T parse(final StringReader reader, final S source)`                                                                |  If overwritten, this method will be preferred to `T parse(StringReader)`. It serves the same purpose, but allows to also   include the source in the parsing logic.
-| `default Collection<String> getExamples()`                                                                                      |  This method should **not** be extended. It is used internally to differentiate certain argument types while parsing.                                                                             |
-| `default <S> CompletableFuture<Suggestions> listSuggestions(final CommandContext<S> context, final SuggestionsBuilder builder)` |  This method is the equivalent of `RequiredArgumentBuilder#suggests(SuggestionProvider<S>)`. You can overwrite this method in order to send your own suggestions to the client. |
+| `ArgumentType<N> getNativeType()`                                                                                               |  Here, you declare the underlying argument type, which is used as a base for client-side argument validation.                                                                                             |
+| `T parse(final StringReader reader) throws CommandSyntaxException`                                                              |  This method is used if `T parse(StringReader, S)` is not overridden. In here, you can run conversion and validation logic.                                                                             |
+| `default <S> T parse(final StringReader reader, final S source)`                                                                |  If overridden, this method will be preferred to `T parse(StringReader)`. It serves the same purpose, but allows including the source in the parsing logic.
+| `default Collection<String> getExamples()`                                                                                      |  This method should **not** be overridden. It is used internally to differentiate certain argument types while parsing.                                                                             |
+| `default <S> CompletableFuture<Suggestions> listSuggestions(final CommandContext<S> context, final SuggestionsBuilder builder)` |  This method is the equivalent of `RequiredArgumentBuilder#suggests(SuggestionProvider<S>)`. You can override this method in order to send your own suggestions to the client. |
 
 ### A very basic implementation
 ```java
@@ -179,7 +179,7 @@ you can also manually read input. Here, we read an unquoted string, the same as
 
 ## `CustomArgumentType.Converted<T, N>`
 In case that you need to parse the native type to your new type, you can instead use the `CustomArgumentType.Converted` interface.
-This interface is an extension to the `CustomArgumentType` interface, which adds two new, overwritable methods:
+This interface is an extension to the `CustomArgumentType` interface, which adds two new, overridable methods:
 
 ```java
 T convert(N nativeType) throws CommandSyntaxException;