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
RootCommandSets the argument type for a parameter/argument.
Represents the command parameter required
by the usage of the command itself
Represents a custom data structure made specifically
for handling the arguments entered by the
CommandSourceThrown when a raw argument string cannot be parsed into the expected type.
Base class for defining parameter types in a command processing framework.
Handler for resolving
ArgumentType instances for complex or specialized types.Functional interface for resolving nested/component types during argument type resolution.
Registry for
ArgumentType instances, managing type resolution through a chain of handlers.Validates a parsed command argument.
Handler for resolving
ArgumentType instances for array types.Marks a command handling method to be executed asynchronously.
Represents a class that's responsible for
Handling all auto-completion processes during
tab-completion per one command, regardless of the sender valueType
A base implementation of
ThrowableHandler that provides intelligent
exception chain traversal and resolution logic.An extension of
Event that supports cancellation.Handler for resolving
ArgumentType instances for Collection types.Represents a wrapper for the actual command's data
Visits each element in a
ClassElementRepresents the processes context of a command
entered by
CommandSourceBase class for all command-related events in the Imperat framework.
A functional interface for handling and resolving exceptions that occur during
Imperat's command execution flow.
This class represents the execution/action of this command that's triggered when
the sender asks for this command to be executed.
Represents a usage of a command
that can be used in the future during an execution
Defines a functional interface that processes a
CommandContext
AFTER the resolving of the arguments into values.Event fired after a command registration attempt completes, whether successful or failed.
Defines a functional interface that processes a
CommandContext
BEFORE the resolving of the arguments into values.Event fired before a command is registered to the command dispatcher.
Represents the sender/source
of a command being executed
may be a console, a player in a game, etc...
Represents a tree structure for commands, providing methods for parsing, matching,
and tab-completion functionality within a command framework.
Handler for resolving
ArgumentType instances for CompletableFuture types.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.
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
ContextArgumentProviderRepresents a way for defining
how the context is created
Applies a per-invocation cooldown to a command method.
Cool-down checker and handler for the command usages
CommandPathwayRepresents a required cooldown of a
CommandPathwayRepresents a cursor of command input that provides sequential access to command arguments,
parameters, and individual characters.
Specifies 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.
Handler for resolving
ArgumentType instances for Either types.Selects a
ParseElement based on a specific list of RuleHandler for resolving
ArgumentType instances for enum types.Base marker interface for all events that can be handled by the
EventBus.A high-performance, thread-safe event bus system with priority-based handler execution.
Builder for creating configured
EventBus instances.A functional interface for handling exceptions that occur during event handler execution.
Represents a single subscription to a specific event type on an
EventBus.Declares a method as a handler for a specific
Throwable type.Declares a command usage method and provides example invocations for help output.
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.
Defines the execution strategy for event handlers registered with the
EventBus.Annotation to mark a method as a return value resolver for a command.
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
CommandSourceA 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.
Marks a parameter or type as greedy, consuming the remainder of the input
instead of a single token (e.g., capturing full sentences).
Represents a final, immutable entry for a single executable command in the help system.
Factory interface for creating
HelpEntry instances from command pathways.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 based on
CommandPathway.Interface for rendering help documentation.
An immutable data class representing a query for help documentation.
A builder class for creating instances of
HelpQuery.A theme for help documentation generation and presentation.
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.Marks a parameter as inherited from an ancestor command's pathway.
Functional interface for creating instances of a given class.
Thrown when a command's syntax does not match any valid usage pathway.
Handler for resolving
ArgumentType instances for Map types.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.
Represents a behavior that deals with numeric
inputs if they are ranged from min to max using
NumericRangeHandler for resolving
ArgumentType instances for numeric types.Marks a parameter or type as optional.
Handler for resolving
ArgumentType instances for Optional types.Defines the execution or evaluation priority of an element.
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.
Thrown when a command source lacks the required permission to execute a command or usage.
Represents an entity that can hold a permission.
Represents the relative priority used when resolving command parameters.
A collection that maintains elements sorted by their
Priority.Marks a method as a
CommandProcessor, which is a method that is executed after the command is
executed, regardless of the outcome.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.
Base class for all exceptions whose user-facing message is driven by the
ResponseRegistry — i.e.An interface that represents a way to handle a returned value from a method
that does is NOT void.
Declares a command entry point on a type or method.
Represents a root command class information
Marks a command or command class/method as secret, meaning it will not be listed in help commands
and may be hidden from tab-completion results.
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.
An
ArgumentTypeHandler that wraps a simple Supplier for non-generic types.An interface whose single responsibility is to resolve
SourceProvider
into SourceProvider 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 displays help entries in a flat list format.
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.Strategy interface responsible for printing throwables that are
caught but not otherwise handled.
Represents the result of a direct tree execution.
The status of a tree execution.
Provides help data by visiting the command tree, node by node.
Interface for formatting command usage paths into displayable help components.
Container annotation for declaring one or more
ArgValidator types on a command type
or a specific parameter.Restricts a parameter to a predefined set of allowed string values.