All Classes and Interfaces
Class
Description
A
Description that describes an annotationMethods annotated with AutoComplete will be registered as a handler for
AutoCompleteEvents for the given
Commands.Representation of an auto complete handler.
Representation of an auto complete rule.
This class is a subclass of
Event.The bundle annotation states which localization bundle is to be used
in a certain scope.
Methods annotated with
Button will be registered as a button at startup.Representation of a button.
Annotation used to add choices to parameters.
A
Description that describes a class.ClassFinders search for classes annotated with a specific annotationMethods annotated with Command will be registered as a slash command at startup.
Used to configure the registration of commands.
Common interface for command interaction definitions.
Stores the configuration values for registering commands.
Builder for
CommandDefinition.CommandConfig.This class is a subclass of
Event.Enum describing the two possible scopes a command can be registered for.
A tree data structure representing slash commands sorted into Subcommands and SubcommandGroups.
Represents a component, namely
Button, StringSelectMenu or EntitySelectMenu, that should be added to a reply.Common interface for component interaction definitions.
This class is a subclass of
Event.Builder for sending messages based on a
GenericInteractionCreateEvent that supports adding components to
messages and changing the InteractionDefinition.ReplyConfig.Will be thrown if anything goes wrong while configuring jda-commands.
Indicates that an annotation type can be used for parameter validation.
A
Middleware implementation that will check the parameter constraints a SlashCommandDefinition might have.Representation of a context command.
Commands annotated with Cooldown will have a per-user cooldown.
A
Middleware implementation that contains the business logic behind command cooldowns.Representation of a custom id used in modals, buttons or select menus.
Indicates that the implementing
Definition can be transformed into a JDA entity that has a CustomId.The default implementation of
ErrorMessageFactory.Default implementation of
GuildScopeProvider.Default implementation of
PermissionsProvider with the following behaviour:The common interface for all interaction definitions and their sub parts, such as parameters or text inputs, etc.
The common interface of all
Description types.A collection of classes relevant for
EventHandlers.Subclass of
EmbedBuilder that supports placeholders and easier manipulation of fields.Methods for manipulating the fields of an
Embed.Builder for configuring the Embed API of JDA-Commands.
An
EmbedDataSource is used to retrieve Embeds based on a unique name from various sources.Container for immutably holding the embed configuration made by
EmbedConfig.Methods annotated with EntitySelectMenu will be registered as a EntitySelectMenu at startup.
An implementation of
Component specific to EntitySelectMenuRepresentation of an entity select menu.
Generic interface for factory classes that provide
MessageCreateData that should be sent for common errors that
happen during an interaction execution, such as missing permissions or failing constraints.Holds the respective
GenericInteractionCreateEvent and InteractionDefinition of an error.Abstract base event for all interaction events, like
CommandEvent.Implementations of this class are handling specific
GenericInteractionCreateEvents.Classes implementing
ExpirationStrategy define a strategy when a Runtime should be closed.ExpirationStrategy that closes a Runtime after the passed amount of time.Implementations of this interface, that are registered by Javas service provider interface, will be called
in
JDACBuilder to configure the framework.Implementations of this interface are providing additional configuration to implementations of
Extension.The default variant of
Localizer, which implements it with help of the amazing
java implementation of project fluent.Custom
Extension.Data to be used to configure this extension.Interface for declaring on which Guilds a guild scoped command should be registered.
Collection of helper methods that are used inside the framework.
This class serves as an interface for application localization.
A placeholder identified by its name with the value to be substituted.
Instances of
Implementation are used to provide custom implementations of Implementation.ExtensionProvidable interfaces, namely:Indicates that the annotated class is a custom implementation that should replace the default implementation.
A marker interface that all types providable by an
Extension share.A class annotated with
Implementation.Middleware will be automatically searched for and instantiated as a
Middleware by guice.A container type for providing
Middlewares.A class annotated with
Implementation.TypeAdapter will be automatically searched for and instantiated as a
TypeAdapter by guice.A container type for providing
TypeAdapters.A class annotated with
Implementation.Validator will be automatically searched for and instantiated as a
Validator by guice.A container type for providing
Validators.Classes annotated with
Interaction are responsible for defining and handling interactions.An
InteractionControllerInstantiator is used get instances of classes annotated with Interaction, if needed creating those.Common interface for all definitions that represent an interaction.
Stores the configuration values for sending replies.
Builder for
InteractionDefinition.ReplyConfig.Central registry for all
InteractionDefinitions.Will be thrown if anything goes wrong internally.
Will be thrown if any errors are made in the declaration of interactions.
Bundles data that is important for the execution of an interaction, especially for invoking the user defined method.
Indicates that the implementing
Definition is bound to a method that can be invoked.A functional interface, that allows the invocation of a
MethodDescription.This builder is used to build instances of
JDACommands.The two available filter strategies
Readonly view of a
JDACBuilder.Base exception for all exceptions thrown by JDA-Commands.
The main entry point of the JDA-Commands framework.
Wrapper class for
JDA and ShardManager.Indicates that the implementing
Definition can be transformed into a JDA entity.Handles incoming
GenericInteractionCreateEvents and maps them to their corresponding Runtime, creating new ones if needed.A simple key-value-store to store variables between events.
A
Localizer is used to localize a given key for a specific bundle and locale.The annotated element must be a number whose value must be less or equal to the specified maximum.
Used to define
SelectOptions
for StringSelectMenus.InternalException wrapper for repeating
MenuOptions.Holds all objects needed to create an
InteractionDefinition.A
Description that describes a method.Middlewares run just before an interaction event gets dispatched.
Central registry for all
Middlewares.The annotated element must be a number whose value must be greater or equal to the specified minimum.
Methods annotated with
Modal will be registered as a modal at startup.Builder for
Modals.Representation of a modal.
Representation of a modal text input defined by
TextInputThis class is a subclass of
Event.Subtype of
ReplyableEvent that also supports replying with a Modal.The annotated element must be a user or member that doesn't have the specified discord permission.
Representation of a slash command option.
Representation of a parameter constraint defined by a constraint annotation.
A
Description that describes a Package.Annotation used to add metadata, e.g.
A
Description that describes a parameter.The annotated element must be a user or member that have the specified discord permission.
Interaction classes or
interaction methods (commands, components or modals) annotated with Permission will
require the user to have the given permissions in order to execute the command.A
Middleware implementation that will check permissions.Interface for performing permission checks.
Enum to define with witch priority a
Middleware should be executed.Common interface for classes that support simple message replies to
GenericInteractionCreateEvent.Subtype of
Event that supports replying to the GenericInteractionCreateEvent with text messages.Implementation of
Reply handling all the business logic of sending messages.Used to configure the reply behaviour of interaction replies.
A
Runtime delegates the jda events to their corresponding EventHandler and manages the used virtual threads.An implementation of
Component specific to SelectMenu.Common interface for select menu definitions.
Subtype of
ConfigurableReply that allows replying without message content (SendableReply.reply()).Representation of a slash command.
Representation of a cooldown definition defined by
Cooldown.Class that sends the
CommandData to Discord.An implementation of
Component specific to StringSelectMenuMethods annotated with StringSelectMenu will be registered as a StringSelectMenu at startup.
Representation of a string select menu.
Representation of a select option for a string select menu defined by a
MenuOption.Annotation used to add TextInputs to
Modals.Single node inside the
CommandTree.Generic top level interface for type adapting.
Central registry for all type adapters.
Validators check if a command option fulfills the given constraint.
This context provides access to the
InvocationContext of this interaction and
has some utility methods useful for error messages.Central registry for all
Validators.