GenericArguments (SpongeAPI 7.3.0 API)

java.lang.Object
- org.spongepowered.api.command.args.GenericArguments

```
public final class GenericArguments
extends Object
```
Class containing factory methods for common command elements.

Method Summary

All Methods Static Methods Concrete Methods
Modifier and Type	Method and Description
`static CommandElement`	`allOf(CommandElement element)` Require all remaining args to match as many instances of `CommandElement` as will fit.
`static CommandElement`	`bigDecimal(Text key)` Expect an argument to return a `BigDecimal`.
`static CommandElement`	`bigInteger(Text key)` Expect an argument to return a `BigInteger`.
`static CommandElement`	`bool(Text key)` Require an argument to be a boolean.
`static <T extends CatalogType> CommandElement`	`catalogedElement(Text key, Class<T> catalogType)` Expect an argument that is a member of the specified `CatalogType` T.
`static CommandElement`	`choices(Text key, Map<String,?> choices)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`choices(Text key, Map<String,?> choices, boolean choicesInUsage)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`choices(Text key, Map<String,?> choices, boolean choicesInUsage, boolean caseSensitive)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`choices(Text key, Supplier<Collection<String>> keys, Function<String,?> values)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`choices(Text key, Supplier<Collection<String>> keys, Function<String,?> values, boolean choicesInUsage)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`choicesInsensitive(Text key, Map<String,?> choices)` Return an argument that allows selecting from a limited set of values.
`static CommandElement`	`dataContainer(Text key)` Expect an argument to be a valid `DataContainer`.
`static CommandElement`	`dateTime(Text key)` Expect an argument to be a date-time, in the form of a `LocalDateTime`.
`static CommandElement`	`dateTimeOrNow(Text key)` Expect an argument to be a date-time, in the form of a `LocalDateTime`.
`static CommandElement`	`dimension(Text key)` Expect an argument to represent a dimension.
`static CommandElement`	`doubleNum(Text key)` Require an argument to be an double-precision floating point number.
`static CommandElement`	`duration(Text key)` Expect an argument to be a `Duration`.
`static CommandElement`	`entity(Text key)` Expect an argument to represent an `Entity`.
`static CommandElement`	`entity(Text key, Class<? extends Entity> clazz)` Expect an argument to represent an `Entity` of the specified type.
`static CommandElement`	`entity(Text key, EntityType type)` Expect an argument to represent an `Entity` of the specified `EntityType`.
`static CommandElement`	`entityOrSource(Text key)` Expect an argument to represent an `Entity`, or if the argument is not present and the `CommandSource` is an entity, return the source.
`static CommandElement`	`entityOrTarget(Text key)` Expect an argument to represent an `Entity`, or if the argument is not present and the `CommandSource` is looking at an entity, return that entity.
`static CommandElement`	`entityOrTarget(Text key, Class<? extends Entity> clazz)` Expect an argument to represent an `Entity` of the specified type, or if the argument is not present and the `CommandSource` is looking at an applicable entity, return that entity.
`static CommandElement`	`entityOrTarget(Text key, EntityType type)` Expect an argument to represent an `Entity` of the specified `EntityType`, or if the argument is not present and the `CommandSource` is looking at an applicable entity, return that entity.
`static <T extends Enum<T>> CommandElement`	`enumValue(Text key, Class<T> type)` Require the argument to be a key under the provided enum.
`static CommandElement`	`firstParsing(CommandElement... elements)` Returns a command element that matches the first of the provided elements that parses tab completion matches from all options.
`static CommandFlags.Builder`	`flags()` Gets a builder to create a command element that parses flags.
`static CommandElement`	`integer(Text key)` Require an argument to be an integer (base 10).
`static CommandElement`	`ip(Text key)` Expect an argument to return an IP address, in the form of an `InetAddress`.
`static CommandElement`	`ipOrSource(Text key)` Expect an argument to return an IP address, in the form of an `InetAddress`, or if nothing matches and the source is a `RemoteSource`, return the source's address.
`static CommandElement`	`literal(Text key, Object putValue, String... expectedArgs)` Expect a literal sequence of arguments.
`static CommandElement`	`literal(Text key, String... expectedArgs)` Expect a literal sequence of arguments.
`static CommandElement`	`location(Text key)` Expect an argument to represent a `Location`.
`static CommandElement`	`longNum(Text key)` Require an argument to be a long (base 10).
`static CommandElement`	`markTrue(Text key)` Expects no arguments.
`static CommandElement`	`none()` Expects no arguments, returns no values.
`static CommandElement`	`onlyOne(CommandElement element)` Restricts the given command element to only insert one value into the context at the provided key.
`static CommandElement`	`optional(CommandElement element)` Make the provided command element optional.
`static CommandElement`	`optional(CommandElement element, Object value)` Make the provided command element optional.
`static CommandElement`	`optionalWeak(CommandElement element)` Make the provided command element optional This means the command element is not required.
`static CommandElement`	`optionalWeak(CommandElement element, Object value)` Make the provided command element optional.
`static CommandElement`	`player(Text key)` Expect an argument to represent online players.
`static CommandElement`	`playerOrSource(Text key)` Expect an argument to represent online players, or if nothing matches and the source is a `Player`, give the player.
`static CommandElement`	`plugin(Text key)` Expect an argument to represent a `PluginContainer`'s id.
`static CommandElement`	`remainingJoinedStrings(Text key)` Require one or more strings, which are combined into a single, space-separated string.
`static CommandElement`	`remainingRawJoinedStrings(Text key)` Require one or more strings, without any processing, which are combined into a single, space-separated string.
`static CommandElement`	`repeated(CommandElement element, int times)` Require a given command element to be provided a certain number of times.
`static CommandElement`	`requiringPermission(CommandElement element, String permission)` Checks a permission for a given command argument to be used.
`static CommandElement`	`requiringPermissionWeak(CommandElement element, String permission)` Checks a permission for a given command argument to be used.
`static CommandElement`	`seq(CommandElement... elements)` Consumes a series of arguments.
`static CommandElement`	`string(Text key)` Require an argument to be a string.
`static CommandElement`	`text(Text key, TextSerializer serializer, boolean allRemaining)` Expect an argument to be valid `Text`.
`static CommandElement`	`url(Text key)` Expect an argument to represent a `URL`.
`static CommandElement`	`user(Text key)` Expect an argument to represent players who have been online at some point, as a `User`.
`static CommandElement`	`userOrSource(Text key)` Expect an argument to represent players who have been online at some point, as a `User`, or if nothing matches and the source is a `User`, give the user.
`static CommandElement`	`uuid(Text key)` Expect an argument to be a `UUID`.
`static CommandElement`	`vector3d(Text key)` Expect an argument to represent a `Vector3d`.
`static CommandElement`	`withConstrainedSuggestions(CommandElement argument, Predicate<String> predicate)` Filters an argument's suggestions.
`static CommandElement`	`withSuggestions(CommandElement argument, Function<CommandSource,Iterable<String>> suggestions)` Uses a custom set of suggestions for an argument.
`static CommandElement`	`withSuggestions(CommandElement argument, Function<CommandSource,Iterable<String>> suggestions, boolean requireBegin)` Uses a custom set of suggestions for an argument.
`static CommandElement`	`withSuggestions(CommandElement argument, Iterable<String> suggestions)` Uses a custom set of suggestions for an argument.
`static CommandElement`	`withSuggestions(CommandElement argument, Iterable<String> suggestions, boolean requireBegin)` Uses a custom set of suggestions for an argument.
`static CommandElement`	`world(Text key)` Expect an argument to represent a world.

Methods inherited from class java.lang.Object
clone, equals, finalize, getClass, hashCode, notify, notifyAll, toString, wait, wait, wait

- Method Detail
  - none
```
public static CommandElement none()
```
    Expects no arguments, returns no values.
    
    Returns:
    
    An expectation of no arguments
  - markTrue
```
public static CommandElement markTrue(Text key)
```
    Expects no arguments. Adds 'true' to the context when parsed.
    This will return only one value.
    
    Parameters:
    
    key - the key to store 'true' under
    
    Returns:
    
    the argument
  - playerOrSource
```
public static CommandElement playerOrSource(Text key)
```
    Expect an argument to represent online players, or if nothing matches and the source is a Player, give the player. If nothing matches and the source is not a player, throw an exception.
    Gives values of type Player.
    
    This argument accepts the following inputs:
    - A player's name
    - A regex that matches the beginning of one or more player's names
    - A selector
    This may return multiple players. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - player
```
public static CommandElement player(Text key)
```
    Expect an argument to represent online players. Returns values of type Player.
    This argument accepts the following inputs:
    - A player's name
    - A regex that matches the beginning of one or more player's names
    - A selector
    This may return multiple players. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - user
```
public static CommandElement user(Text key)
```
    Expect an argument to represent players who have been online at some point, as a User.
    This argument accepts the following inputs:
    - A player's name (offline or online)
    - A regex that matches the beginning of one or more player's names
    - A selector
    This may return multiple Users. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    
    This may not return the Player object for an online user. If you wish to operate on an associated Player object if the user is online, use User.getPlayer().
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - userOrSource
```
public static CommandElement userOrSource(Text key)
```
    Expect an argument to represent players who have been online at some point, as a User, or if nothing matches and the source is a User, give the user. If nothing matches and the source is not a User, throw an exception.
    This argument accepts the following inputs:
    - A player's name (offline or online)
    - A regex that matches the beginning of one or more player's names
    - A selector
    This may return multiple Users. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    
    This may not return the Player object for an online user. If you wish to operate on an associated Player object if the user is online, use User.getPlayer().
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - world
```
public static CommandElement world(Text key)
```
    Expect an argument to represent a world. This returns WorldProperties objects rather than an actual World in order to include unloaded worlds.
    This argument accepts the following inputs:
    - A world's name
    - A regex that matches the beginning of one or more world's names
    This may return multiple WorldPropertiess. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - dimension
```
public static CommandElement dimension(Text key)
```
    Expect an argument to represent a dimension. Returns values of type DimensionType.
    This argument accepts the following inputs:
    - A dimension's id
    - A regex that matches the beginning of one or more dimension id
    This may return multiple DimensionTypes. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - vector3d
```
public static CommandElement vector3d(Text key)
```
    Expect an argument to represent a Vector3d.
    This will return one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - location
```
public static CommandElement location(Text key)
```
    Expect an argument to represent a Location.
    This will return one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - catalogedElement
```
public static <T extends CatalogType> CommandElement catalogedElement(Text key,
                                                                      Class<T> catalogType)
```
    Expect an argument that is a member of the specified CatalogType T.
    This argument accepts the following inputs:
    - The value's CatalogType.getId()
    - A regex that matches the beginning of one or more ids
    This may return multiple instances of T. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Type Parameters:
    
    T - The type to return
    
    Parameters:
    
    key - The key to store the resolved value under
    
    catalogType - The expected CatalogType
    
    Returns:
    
    the argument
  - plugin
```
public static CommandElement plugin(Text key)
```
    Expect an argument to represent a PluginContainer's id.
    This argument accepts the following inputs:
    - The specified PluginContainer's id
    - A regex that matches the beginning of one or more plugin id
    This may return multiple PluginContainers. If you must only return one, wrap this element in an onlyOne(CommandElement) call.
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - flags
```
public static CommandFlags.Builder flags()
```
    Gets a builder to create a command element that parses flags.
    There should only be ONE of these in a command element sequence if you wish to use flags. A CommandFlags.Builder can handle multiple flags that have different behaviors. Using multiple builders in the same sequence may cause unexpected behavior.
    
    Any command elements that are not associated with flags should be placed into the CommandFlags.Builder.buildWith(CommandElement) parameter, allowing the flags to be used throughout the argument string.
    
    Returns:
    
    the newly created builder
  - seq
```
public static CommandElement seq(CommandElement... elements)
```
    Consumes a series of arguments. Usage is the elements concatenated
    
    Parameters:
    
    elements - The series of arguments to expect
    
    Returns:
    
    the element to match the input
  - choices
```
public static CommandElement choices(Text key,
                                     Map<String,?> choices)
```
    Return an argument that allows selecting from a limited set of values.
    If there are 5 or fewer choices available, the choices will be shown in the command usage. Otherwise, the usage will only display only the key.
    
    Choices are case sensitive. If you do not require case sensitivity, see choicesInsensitive(Text, Map).
    
    To override this behavior, see choices(Text, Map, boolean, boolean).
    
    When parsing, only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    choices - The choices users can choose from
    
    Returns:
    
    the element to match the input
  - choicesInsensitive
```
public static CommandElement choicesInsensitive(Text key,
                                                Map<String,?> choices)
```
    Return an argument that allows selecting from a limited set of values.
    If there are 5 or fewer choices available, the choices will be shown in the command usage. Otherwise, the usage will only display only the key.
    
    Choices are not case sensitive. If you require case sensitivity, see choices(Text, Map)
    
    To override this behavior, see choices(Text, Map, boolean, boolean).
    
    When parsing, only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    choices - The choices users can choose from
    
    Returns:
    
    the element to match the input
  - choices
```
public static CommandElement choices(Text key,
                                     Map<String,?> choices,
                                     boolean choicesInUsage)
```
    Return an argument that allows selecting from a limited set of values.
    Unless choicesInUsage is true, general command usage will only display the provided key.
    
    Choices are case sensitive. If you do not require case sensitivity, see choices(Text, Map, boolean, boolean)
    
    When parsing, only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    choices - The choices users can choose from
    
    choicesInUsage - Whether to display the available choices, or simply the provided key, as part of usage
    
    Returns:
    
    the element to match the input
  - choices
```
public static CommandElement choices(Text key,
                                     Map<String,?> choices,
                                     boolean choicesInUsage,
                                     boolean caseSensitive)
```
    Return an argument that allows selecting from a limited set of values.
    Unless choicesInUsage is true, general command usage will only display the provided key.
    
    When parsing, only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    choices - The choices users can choose from
    
    choicesInUsage - Whether to display the available choices, or simply the provided key, as part of usage
    
    caseSensitive - Whether the matches should be case sensitive
    
    Returns:
    
    the element to match the input
  - choices
```
public static CommandElement choices(Text key,
                                     Supplier<Collection<String>> keys,
                                     Function<String,?> values)
```
    Return an argument that allows selecting from a limited set of values.
    If there are 5 or fewer choices available, the choices will be shown in the command usage. Otherwise, the usage will only display only the key.
    
    To override this behavior, see choices(Text, Map, boolean).
    
    Only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    keys - The function that will supply available keys
    
    values - The function that maps an element of key to a value and any other key to null
    
    Returns:
    
    the element to match the input
  - choices
```
public static CommandElement choices(Text key,
                                     Supplier<Collection<String>> keys,
                                     Function<String,?> values,
                                     boolean choicesInUsage)
```
    Return an argument that allows selecting from a limited set of values. Unless choicesInUsage is true, general command usage will only display the provided key.
    Only one choice may be selected, returning its associated value.
    
    Parameters:
    
    key - The key to store the resulting value under
    
    keys - The function that will supply available keys
    
    values - The function that maps an element of key to a value and any other key to null
    
    choicesInUsage - Whether to display the available choices, or simply the provided key, as part of usage
    
    Returns:
    
    the element to match the input
  - firstParsing
```
public static CommandElement firstParsing(CommandElement... elements)
```
    Returns a command element that matches the first of the provided elements that parses tab completion matches from all options.
    
    Parameters:
    
    elements - The elements to check against
    
    Returns:
    
    The command element matching the first passing of the elements provided
  - optional
```
public static CommandElement optional(CommandElement element)
```
    Make the provided command element optional.
    This means the command element is not required. However, if the element is provided with invalid format and there are no more args specified, any errors will still be passed on.
    
    Parameters:
    
    element - The element to optionally require
    
    Returns:
    
    the element to match the input
  - optional
```
public static CommandElement optional(CommandElement element,
                                      Object value)
```
    Make the provided command element optional.
    This means the command element is not required. However, if the element is provided with invalid format and there are no more args specified, any errors will still be passed on. If the given element's key and value are not null and this element is not provided the element's key will be set to the given value.
    
    Parameters:
    
    element - The element to optionally require
    
    value - The default value to set
    
    Returns:
    
    the element to match the input
  - optionalWeak
```
public static CommandElement optionalWeak(CommandElement element)
```
    Make the provided command element optional This means the command element is not required. If the argument is provided but of invalid format, it will be skipped.
    
    Parameters:
    
    element - The element to optionally require
    
    Returns:
    
    the element to match the input
  - optionalWeak
```
public static CommandElement optionalWeak(CommandElement element,
                                          Object value)
```
    Make the provided command element optional.
    
    This means the command element is not required.
    - If the argument is provided but of invalid format, it will be skipped.
    - If the given element's key and value are not null and this element is not provided the element's key will be set to the given value.
    Parameters:
    
    element - The element to optionally require
    
    value - The default value to set
    
    Returns:
    
    the element to match the input
  - repeated
```
public static CommandElement repeated(CommandElement element,
                                      int times)
```
    Require a given command element to be provided a certain number of times.
    Command values will be stored under their provided keys in the CommandContext.
    
    Parameters:
    
    element - The element to repeat
    
    times - The number of times to repeat the element.
    
    Returns:
    
    the element to match the input
  - allOf
```
public static CommandElement allOf(CommandElement element)
```
    Require all remaining args to match as many instances of CommandElement as will fit. Command element values will be stored under their provided keys in the CommandContext.
    
    Parameters:
    
    element - The element to repeat
    
    Returns:
    
    the element to match the input
  - string
```
public static CommandElement string(Text key)
```
    Require an argument to be a string. Any provided argument will fit in under this argument.
    Gives values of type String. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - integer
```
public static CommandElement integer(Text key)
```
    Require an argument to be an integer (base 10).
    Gives values of type Integer. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - longNum
```
public static CommandElement longNum(Text key)
```
    Require an argument to be a long (base 10).
    Gives values of type Long. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - doubleNum
```
public static CommandElement doubleNum(Text key)
```
    Require an argument to be an double-precision floating point number.
    Gives values of type Double. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - bool
```
public static CommandElement bool(Text key)
```
    Require an argument to be a boolean.
    The recognized true values are:
    - true
    - t
    - yes
    - y
    - verymuchso
    The recognized false values are:
    - false
    - f
    - no
    - n
    - notatall
    Gives values of type Boolean. This will return only one value.
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - enumValue
```
public static <T extends Enum<T>> CommandElement enumValue(Text key,
                                                           Class<T> type)
```
    Require the argument to be a key under the provided enum.
    Gives values of type T. This will return only one value.
    
    Type Parameters:
    
    T - The type of enum
    
    Parameters:
    
    key - The key to store the matched enum value under
    
    type - The enum class to get enum constants from
    
    Returns:
    
    the element to match the input
  - remainingJoinedStrings
```
public static CommandElement remainingJoinedStrings(Text key)
```
    Require one or more strings, which are combined into a single, space-separated string.
    Gives values of type String. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - remainingRawJoinedStrings
```
public static CommandElement remainingRawJoinedStrings(Text key)
```
    Require one or more strings, without any processing, which are combined into a single, space-separated string.
    Gives values of type String. This will return only one value.
    
    Parameters:
    
    key - The key to store the parsed argument under
    
    Returns:
    
    the element to match the input
  - literal
```
public static CommandElement literal(Text key,
                                     String... expectedArgs)
```
    Expect a literal sequence of arguments. This element matches the input against a predefined array of arguments expected to be present, case-insensitively.
    This will return only one value.
    
    Parameters:
    
    key - The key to add to the context. Will be set to a value of true if this element matches
    
    expectedArgs - The sequence of arguments expected
    
    Returns:
    
    the appropriate command element
  - literal
```
public static CommandElement literal(Text key,
                                     @Nullable
                                     Object putValue,
                                     String... expectedArgs)
```
    Expect a literal sequence of arguments. This element matches the input against a predefined array of arguments expected to be present, case-insensitively.
    This will return only one value.
    
    Parameters:
    
    key - The key to store this argument as
    
    putValue - The value to put at key if this argument matches. May be null
    
    expectedArgs - The sequence of arguments expected
    
    Returns:
    
    the appropriate command element
  - onlyOne
```
public static CommandElement onlyOne(CommandElement element)
```
    Restricts the given command element to only insert one value into the context at the provided key.
    If more than one value is returned by an element, or the target key already contains a value, this will throw an ArgumentParseException
    
    Parameters:
    
    element - The element to restrict
    
    Returns:
    
    the restricted element
  - requiringPermission
```
public static CommandElement requiringPermission(CommandElement element,
                                                 String permission)
```
    Checks a permission for a given command argument to be used.
    If the element attempts to parse an argument and the user does not have the permission, an ArgumentParseException will be thrown.
    
    Parameters:
    
    element - The element to wrap
    
    permission - The permission to check
    
    Returns:
    
    the element
  - requiringPermissionWeak
```
public static CommandElement requiringPermissionWeak(CommandElement element,
                                                     String permission)
```
    Checks a permission for a given command argument to be used.
    If the element attempts to parse an argument and the user does not have the permission, the element will be skipped over.
    
    If the invoking CommandSource has permission to use the element, but the wrapped element fails to parse, an exception will be reported in the normal way. If you require this element to be truly optional, wrap this element in either optional(CommandElement) or optionalWeak(CommandElement), as required.
    
    Parameters:
    
    element - The element to wrap
    
    permission - The permission to check
    
    Returns:
    
    the element
  - entity
```
public static CommandElement entity(Text key)
```
    Expect an argument to represent an Entity.
    This argument accepts the following inputs:
    - A player's name
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - entity
```
public static CommandElement entity(Text key,
                                    Class<? extends Entity> clazz)
```
    Expect an argument to represent an Entity of the specified type.
    This argument accepts the following inputs:
    - A player's name (if appropriate)
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    clazz - The type which the entity must subclass
    
    Returns:
    
    the argument
  - entity
```
public static CommandElement entity(Text key,
                                    EntityType type)
```
    Expect an argument to represent an Entity of the specified EntityType.
    This argument accepts the following inputs:
    - A player's name (if appropriate)
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    type - The type which the entity must be
    
    Returns:
    
    the argument
  - entityOrSource
```
public static CommandElement entityOrSource(Text key)
```
    Expect an argument to represent an Entity, or if the argument is not present and the CommandSource is an entity, return the source.
    This argument accepts the following inputs:
    - A player's name
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - entityOrTarget
```
public static CommandElement entityOrTarget(Text key)
```
    Expect an argument to represent an Entity, or if the argument is not present and the CommandSource is looking at an entity, return that entity.
    This argument accepts the following inputs:
    - A player's name
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - entityOrTarget
```
public static CommandElement entityOrTarget(Text key,
                                            Class<? extends Entity> clazz)
```
    Expect an argument to represent an Entity of the specified type, or if the argument is not present and the CommandSource is looking at an applicable entity, return that entity.
    This argument accepts the following inputs:
    - A player's name (if appropriate)
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    clazz - The type which the entity must subclass
    
    Returns:
    
    the argument
  - entityOrTarget
```
public static CommandElement entityOrTarget(Text key,
                                            EntityType type)
```
    Expect an argument to represent an Entity of the specified EntityType, or if the argument is not present and the CommandSource is looking at an applicable entity, return that entity.
    This argument accepts the following inputs:
    - A player's name (if appropriate)
    - An entity's UUID
    - A regex that matches the beginning of one or more player's names or entities UUIDs.
    - A selector
    Parameters:
    
    key - The key to store under
    
    type - The type which the entity must be
    
    Returns:
    
    the argument
  - url
```
public static CommandElement url(Text key)
```
    Expect an argument to represent a URL.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - ip
```
public static CommandElement ip(Text key)
```
    Expect an argument to return an IP address, in the form of an InetAddress.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - ipOrSource
```
public static CommandElement ipOrSource(Text key)
```
    Expect an argument to return an IP address, in the form of an InetAddress, or if nothing matches and the source is a RemoteSource, return the source's address.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - bigDecimal
```
public static CommandElement bigDecimal(Text key)
```
    Expect an argument to return a BigDecimal.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - bigInteger
```
public static CommandElement bigInteger(Text key)
```
    Expect an argument to return a BigInteger.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - dataContainer
```
public static CommandElement dataContainer(Text key)
```
    Expect an argument to be a valid DataContainer.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - uuid
```
public static CommandElement uuid(Text key)
```
    Expect an argument to be a UUID.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - text
```
public static CommandElement text(Text key,
                                  TextSerializer serializer,
                                  boolean allRemaining)
```
    Expect an argument to be valid Text.
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    serializer - The serializer to parse the text with
    
    allRemaining - If true, consumes all remaining arguments; if false, uses a single argument
    
    Returns:
    
    the argument
  - dateTime
```
public static CommandElement dateTime(Text key)
```
    Expect an argument to be a date-time, in the form of a LocalDateTime. If no date is specified, LocalDate.now() is used; if no time is specified, LocalTime.MIDNIGHT is used.
    Date-times are expected in the ISO-8601 format.
    
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
    
    See Also:
    
    ISO-8601
  - dateTimeOrNow
```
public static CommandElement dateTimeOrNow(Text key)
```
    Expect an argument to be a date-time, in the form of a LocalDateTime. If no date is specified, LocalDate.now() is used; if no time is specified, LocalTime.MIDNIGHT is used.
    If no argument at all is specified, defaults to LocalDateTime.now().
    
    Date-times are expected in the ISO-8601 format.
    
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - duration
```
public static CommandElement duration(Text key)
```
    Expect an argument to be a Duration.
    Durations are expected in the following format: #D#H#M#S. This is not case sensitive.
    
    This will return only one value.
    
    Parameters:
    
    key - The key to store under
    
    Returns:
    
    the argument
  - withSuggestions
```
public static CommandElement withSuggestions(CommandElement argument,
                                             Iterable<String> suggestions)
```
    Uses a custom set of suggestions for an argument. The provided suggestions will replace the regular ones.
    
    Parameters:
    
    argument - The element to replace the suggestions of
    
    suggestions - The suggestions to use
    
    Returns:
    
    the argument
  - withSuggestions
```
public static CommandElement withSuggestions(CommandElement argument,
                                             Iterable<String> suggestions,
                                             boolean requireBegin)
```
    Uses a custom set of suggestions for an argument. The provided suggestions will replace the regular ones.
    If requireBegin is false, then the already typed argument will not be used to filter the provided suggestions.
    
    Parameters:
    
    argument - The element to replace the suggestions of
    
    suggestions - The suggestions to use
    
    requireBegin - Whether or not to require the current argument to begin provided arguments
    
    Returns:
    
    the argument
  - withSuggestions
```
public static CommandElement withSuggestions(CommandElement argument,
                                             Function<CommandSource,Iterable<String>> suggestions)
```
    Uses a custom set of suggestions for an argument. The provided suggestions will replace the regular ones.
    
    Parameters:
    
    argument - The element to replace the suggestions of
    
    suggestions - A function to return the suggestions to use
    
    Returns:
    
    the argument
  - withSuggestions
```
public static CommandElement withSuggestions(CommandElement argument,
                                             Function<CommandSource,Iterable<String>> suggestions,
                                             boolean requireBegin)
```
    Uses a custom set of suggestions for an argument. The provided suggestions will replace the regular ones.
    If requireBegin is false, then the already typed argument will not be used to filter the provided suggestions.
    
    Parameters:
    
    argument - The element to replace the suggestions of
    
    suggestions - A function to return the suggestions to use
    
    requireBegin - Whether or not to require the current argument to begin provided arguments
    
    Returns:
    
    the argument
  - withConstrainedSuggestions
```
public static CommandElement withConstrainedSuggestions(CommandElement argument,
                                                        Predicate<String> predicate)
```
    Filters an argument's suggestions. A suggestion will only be used if it matches the predicate.
    
    Parameters:
    
    argument - The element to filter the suggestions of
    
    predicate - The predicate to test suggestions against
    
    Returns:
    
    the argument

Class GenericArguments

Method Summary

Methods inherited from class java.lang.Object

Method Detail

none

markTrue

playerOrSource

player

user

userOrSource

world

dimension

vector3d

location

catalogedElement

plugin

flags

seq

choices

choicesInsensitive

choices

choices

choices

choices

firstParsing

optional

optional

optionalWeak

optionalWeak

repeated

allOf

string

integer

longNum

doubleNum

bool

enumValue

remainingJoinedStrings

remainingRawJoinedStrings

literal

literal

onlyOne

requiringPermission

requiringPermissionWeak

entity

entity

entity

entityOrSource

entityOrTarget

entityOrTarget

entityOrTarget

url

ip

ipOrSource

bigDecimal

bigInteger

dataContainer

uuid

text

dateTime

dateTimeOrNow

duration

withSuggestions

withSuggestions

withSuggestions

withSuggestions

withConstrainedSuggestions