All Classes and Interfaces
Class
Description
Represents an annotated parameter
from using annotation parser
A class that is responsible for creating
dynamic instances of annotations of certain types
useful while implementing/using
AnnotationReplacerThis interface provides mechanisms for injecting and managing annotations within
a command parsing and execution framework.
Represents a class that has a single responsibility of
reading the annotation components of an annotated command class
Replaces a custom annotation made by the user, with annotations
made from the basic pre-made annotations such as
CommandRepresents a custom data structure made specifically
for handling the arguments entered by the
SourceMarks a command handling method to be executed asynchronously.
Defines the modes of attachment for a subcommand within a
Command.Represents a class that's responsible for
Handling all auto-completion processes during
tab-completion per one command, regardless of the sender valueType
Base class for defining parameter types in a command processing framework.
A base implementation of
ThrowableHandler that provides intelligent
exception chain traversal and resolution logic.Declares a command entry point on a type or method.
Represents a wrapper for the actual command's data
Visits each element in a
ClassElementThis class represents the execution/action of this command that's triggered when
the sender asks for this command to be executed.
Represents a stream of command input that provides sequential access to command arguments,
parameters, and individual characters.
Represents the command parameter required
by the usage of the command itself
Defines a setResult from dispatching the command execution.
Defines a functional interface that processes a
Context
AFTER the resolving of the arguments into values.Defines a functional interface that processes a
Context
BEFORE the resolving of the arguments into values.Represents a tree structure for commands, providing methods for parsing, matching,
and tab-completion functionality within a command framework.
Represents a usage of a command
that can be used in the future during an execution
Represents an argument that's being completed
or an argument requested by the command-sender
to be completed
A generic abstract builder class for configuring instances of ImperatConfig and creating
implementations of the Imperat interface.
Represents the processes context of a command
entered by
SourceRepresents a way for defining
how the context is created
Marks a type or parameter whose value is resolved from the execution context
rather than parsed from the command input.
Resolves a default non-overridable value for
missing required arguments
Represents a context resolver factory
that is responsible for creating
ContextResolverApplies a per-invocation cooldown to a command method.
Cool-down checker and handler for the command usages
CommandUsageSpecifies a literal default value for a parameter
when no explicit input is provided.
Declares an external class that provides/supplies a default value for a parameter
when the user omits an input.
Marks a field to be injected with a dependency by the underlying framework.
A functional interface that supplies a generic dependency
object.
Attaches a human-readable description to a command, subcommand, or parameter.
Represents an entity that can have a description.
Selects a
ParseElement based on a specific list of RuleDeclares a method as a handler for a specific
Throwable type.Represents the execution context for a command, responsible for resolving and managing
command arguments, flags, and their values during command execution.
Represents the result of a command execution operation in the Imperat framework.
Declares external subcommand classes that should be attached to the annotated
command container.
An interface for retrieving the field content.
Declares one or more flag names for a parameter or type.
Represents a flag that has been parsed/read/loaded from a
context of a command entered by the
SourceA class that extracts flags from a single string/argument.
The
FlagRegistrar interface is responsible for managing the registration and retrieval
of free flags in the Imperat command framework.Specifies a format string for parsing and displaying the annotated parameter.
Annotation to forward or redirect the usages of a command/subcommand
to another command/subcommand, therefore, the forwarded command/subcommand
will be executed the same with same input-parameters as the inheriting one.
Sets a default attachment mode for all subcommands under the annotated type or method
when their own attachment mode is
AttachmentMode.UNSET.Marks a parameter or type as greedy, consuming the remainder of the input
instead of a single token (e.g., capturing full sentences).
Represents the result of a parameter handler execution,
controlling chain flow with results per handler per iteration.
Represents a final, immutable entry for a single executable command in the help system.
Factory interface for creating
HelpEntry instances from parameter nodes.A custom list implementation that maintains insertion order, prevents duplicates,
and supports indexing - implemented without using any Java collections.
A functional interface for filtering help entries during query operations.
Factory class providing common help filters.
Interface for rendering help documentation.
An immutable data class representing a query for help documentation.
A builder class for creating instances of
HelpQuery.Rendering options for customizing help display.
An enumeration of the available help documentation layouts.
A theme for help documentation generation and presentation.
Available presentation styles for help display.
Represents the class that handles all
commands' registrations and executions
It also caches the settings that the user can
change or modify in the api.
The
ImperatConfig interface defines the core configuration and interaction points
for a command processing system.Functional interface for creating instances of a given class.
A high-level wrapper, responsible for invoking methods reflectively.
Represents a
MethodCaller that is attached to an instanceFactory for creating
MethodCallers for methods.Assigns a logical name to a command element or parameter.
Functional interface responsible for assigning permissions to command parameter nodes.
Represents a behavior that deals with numeric
inputs if they are ranged from min to max using
NumericRangeMarks a parameter or type as optional.
Represents a type handler for command parameters, providing methods for
type resolution, input matching, and suggestions.
Declares a permission node required to access a command, subcommand, or parameter.
Represents a functional way of checking for the permissions
of the command source/sender.
Represents an entity that can hold a permission.
Represents the class responsible for defining how permissions
are loaded/deduced from a
CommandParameterRegisters one or more
CommandPostProcessor implementations to run
after a command method executes.Registers one or more
CommandPreProcessor implementations to run
before a command method executes.Represents a registrar that allows the configuration and management of pre-processing
and post-processing chains of command processors for a given source type.
Constrains a numeric parameter or type to a minimum/maximum value.
The ResolverRegistrar interface provides mechanisms for registering and retrieving various
types of resolvers, factories, and initializers that are contextually linked to specific
source types and value types.
An interface that represents a way to handle a returned value from a method
that does is NOT void.
Represents a root command class information
Represents the sender/source
of a command being executed
may be a console, a player in a game, etc...
An interface whose single responsibility is to resolve
SourceResolver
into SourceResolver to allow custom command sourcesA sealed interface representing the abstraction for wrapping
and handling sources or senders of commands, and validating
the compatibility of a type as a sender.
Standard help renderer that supports both tree and flat presentation styles.
Standard help provider that queries the command tree.
Declares a subcommand on a type or method, with optional attachment mode and
suggestion-permission behavior.
Provides a fixed set of inline suggestions for a parameter during tab-completion.
Represents the context for auto-completion while providing suggestions
Binds a parameter's suggestions to a named provider registered in the system.
Represents a suggestion providing interface
for an argument/parameter
Declares one or more switch names for a boolean-like parameter.
The
ThrowableHandler interface defines a mechanism for managing and resolving
throwable instances within a given context.A functional interface for handling and resolving exceptions that occur during
Imperat's command execution flow.
Provides help data by visiting the command tree, node by node.
Declares a command usage method and provides example invocations for help output.
Represents a required cooldown of a
CommandUsageInterface for formatting command usage paths into displayable help components.
Happens when the
CommandUsage being registered breaks the rules of a valid usage
These rules are defined by the UsageVerifier.Verifies that the
CommandUsage is suitable
to be added to the commandRestricts a parameter to a predefined set of allowed string values.