All Classes and Interfaces
Class
Description
A class that represents a configuration file
This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
Do not implement this outside KamiCommon. This was a
sealed hierarchy until
spigot-utils dropped to Java 8 so that 1.8.x servers could load it; sealed is Java 17
and has no Java 8 spelling.Do not implement this outside KamiCommon. This was a
sealed hierarchy until
spigot-utils dropped to Java 8 so that 1.8.x servers could load it; sealed is Java 17
and has no Java 8 spelling.This is the abstract adapter for all "KamiCommon structures".
Abstract base class for configuration caches that automatically reload when the underlying config changes.
KamiCommand implementation that lists all features in the provided
Construct an instance of this class and register it under your own
KamiPlugin (see constructor).Construct an instance of this class and register it under your own
KamiCommand class.KamiCommand implementation that lists all modules in the provided
Construct an instance of this class and register it under your own
KamiPlugin (see constructor).Construct an instance of this class and register it under your own
KamiCommand class.Resolves every NMS provider and reports which implementation this server got.
Asserts on what
VersionedComponent emits, across the whole of its surface.Utility for mapping
The format of a line is decided by
String objects into VersionedComponent objects,
handling both legacy color codes and modern MiniMessage format.The format of a line is decided by
ColoredStringParser.detectFormat(String), which tests, in order:
legacy section, legacy ampersand, MiniMessage, then plain text.Resolves whichever supported combat-tag plugin is installed to a single
CombatIntegration, trying
CombatTagPlus, then DeluxeCombat, then PvPManager.The state of a single command invocation, handed to
KamiCommand.perform(CommandContext).Splits already-rendered lines into pages with a titleized header and clickable page-flip arrows.
This object contains the data for an AbstractConfig yaml comment.
This is a utility class for creating and saving configurations in a JavaPlugin
Interface for classes that want to be notified when a config is updated.
You should register this observer with a
You should register this observer with a
ObservableConfig class.Represents a source of configuration data that can provide an
and may optionally support writing/persistence.
Typical implementations:
- File-backed source (writable)
- Provider/remote/in-memory source (read-only)
Contract notes:
- Each call to
- If
-
-
InputStream for readingand may optionally support writing/persistence.
Typical implementations:
- File-backed source (writable)
- Provider/remote/in-memory source (read-only)
Contract notes:
- Each call to
ConfigSource.openStream() should return a fresh stream positioned at the start.- If
ConfigSource.isWritable() is false, ConfigSource.write(byte[], Charset) must throw UnsupportedOperationException.-
ConfigSource.ensureExistsIfWritable() should create any required backing structures for writable sources.-
ConfigSource.asFileIfPresent() returns a File only for file-backed sources; otherwise null.Marks a class as a configuration holder that contains static configuration
values, getters, and setters for its enclosing class.
The ContainerUtil provides an imaginary super class to Collection and Map.
A set of core methods that both
KamiPlugin and Module must follow and implement to make their APIs interchangeable.Encapsulates the default value configuration for a
Parameter.A simple class for sending discord webhooks, supports basic embeds and such
This class represents a single feature registered under your
A feature is a subsystem that acts like its own plugin, providing its own functionality and configuration.
Features cannot be disabled or toggled, they are always enabled.
For a subsystem that can be toggled or disabled, see
KamiPlugin plugin.A feature is a subsystem that acts like its own plugin, providing its own functionality and configuration.
Features cannot be disabled or toggled, they are always enabled.
For a subsystem that can be toggled or disabled, see
Module.The configuration of one
Feature, defaulted from that feature's resource in the plugin jar and
written under the plugin's data folder.A
Supports both read and write (save) operations.
ConfigSource implementation that reads from and writes to a file on the filesystem.Supports both read and write (save) operations.
Represents a layout for a
PaginatedMenu where the available slots for page icons are defined
as the grid between two positions (PositionIconSlot)Do not implement this outside KamiCommon. This was a
sealed hierarchy until
spigot-utils dropped to Java 8 so that 1.8.x servers could load it; sealed is Java 17
and has no Java 8 spelling.Identification of a CommandSender can be done in 4 different ways.
A builder class for wrapping
Patches modify the base metadata and nbt of the item via easier to use methods exposed by this class.
NOTE: Using third party plugins like ItemsAdder which provide custom items IS SUPPORTED!
Just adjust your workflow to parse the
ItemStacks and applying patches to them.Patches modify the base metadata and nbt of the item via easier to use methods exposed by this class.
NOTE: Using third party plugins like ItemsAdder which provide custom items IS SUPPORTED!
Just adjust your workflow to parse the
ItemStack from their API, and then use that object as the prototype for this wrapper:Loader to assist in automatically extracting
Supports the
ItemBuilders from configuration sections.Supports the
KamiConfig system, requiring a ConfigurationSection object to load from.Stand-ins for
String methods added after Java 8.One command in a tree of commands, with typed parameters, requirements and generated help.
Message and Color configuration for KamiCommand messages.
Basic configuration for the help command.
A checked exception whose payload is a message for the sender rather than a stack trace.
A class that represents a configuration file (Meant for implementations WITH a JavaPlugin object available)
If you DO NOT have a JavaPlugin object, it is recommended to use
This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
If you DO NOT have a JavaPlugin object, it is recommended to use
StandaloneConfig instead This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
KamiConfig but with some extended featuresThis subclass adds better constructors.
This subclass adds better constructors.
The
JavaPlugin base for a KamiCommon plugin, adding lifecycle logging, registration helpers that
unregister themselves on disable, an automatically loaded config.yml, and the module and feature
managers.This subclass adds better constructors.
This subclass adds better constructors.
Legacy methods related to
ChatColor and legacy color codes.A legacy color-code translator for Minecraft-style formatting codes.
Translates the alternate code character
Notes:
- This API is marked
Translates the alternate code character
& into the legacy section sign (§) and optionally expands 1.16+ hex color codes of the form &#RRGGBB into the §x§R§R§G§G§B§B sequence used by legacy clients.Notes:
- This API is marked
@Obsolete.Simple colored logger that automatically parse legacy color codes using the section symbol (§) or ampersand (&).
This logger is designed for use in Bukkit/Spigot/Paper plugins, and will prepend the plugin name to each message.
It supports different log levels, and will colorize the output accordingly:
- DEBUG (Level.FINE): Gray
- INFO (Level.INFO): No colorization
- WARNING (Level.WARNING): Yellow
- SEVERE (Level.SEVERE): Red
Note: The logger does not currently support other log levels.
This logger is designed for use in Bukkit/Spigot/Paper plugins, and will prepend the plugin name to each message.
It supports different log levels, and will colorize the output accordingly:
- DEBUG (Level.FINE): Gray
- INFO (Level.INFO): No colorization
- WARNING (Level.WARNING): Yellow
- SEVERE (Level.SEVERE): Red
Note: The logger does not currently support other log levels.
A simple logger service that provides an abstraction for where to log messages.
Override
Override
LoggerService.logToConsole(String, Level) to change how log messages are processed.A Utility class to provide some helper methods when dealing with the Material Flattening changes.
These methods make no guarantee to EXACTLY map your intentions, but they try their best.
These methods make no guarantee to EXACTLY map your intentions, but they try their best.
A nested section of a
StandaloneConfig, exposing the same read and write surface as the config itself over one branch of the
document.Represents the abstraction of a menu into the core parts that
This interface is not meant for public consumption or use, you will find none of the helpful methods you would expect.
Use specific menus classes like
MenuManager needs to interact with.This interface is not meant for public consumption or use, you will find none of the helpful methods you would expect.
Use specific menus classes like
SimpleMenu or PaginatedMenuData class to hold information about a click event on a
Menu.A callback interface for handling
This callback is invoked when a player drags items across slots in the menu inventory.
InventoryDragEvents in a Menu.This callback is invoked when a player drags items across slots in the menu inventory.
InventoryHolder with constructor parameters for making an Inventory with either a row count or an InventoryType.
Also contains a few utility methods for better utilization with the KamiCommon library.
Also contains a few utility methods for better utilization with the KamiCommon library.
Represents a menu icon that can contains the
This class also holds the click data for the icon, and the auto updating logic for the icon
ItemStack data as ItemBuilderThis class also holds the click data for the icon, and the auto updating logic for the icon
Basic configuration for MenuIcon defaults.
Represents a modifier for a
MenuIcon.This manager is responsible for handling all
Developers should not need to interact with this class directly, only through specific menu classes like
Menu interactions.Developers should not need to interact with this class directly, only through specific menu classes like
SimpleMenu or PaginatedMenu.A container for all the options that every
Use Getters and Setters to access and modify these options.
Menu must allow to be configured.Use Getters and Setters to access and modify these options.
Deprecated.
A utility class for sending building messages built from a config.
A cross-version MiniMessage parser and messenger.
This class represents a single module registered under your
A module is a toggleable subsystem that acts like its own plugin, providing its own functionality and configuration.
For a subsystem that cannot be toggled or disabled, see
KamiPlugin plugin.A module is a toggleable subsystem that acts like its own plugin, providing its own functionality and configuration.
For a subsystem that cannot be toggled or disabled, see
Feature.The configuration of one
Module, defaulted from that module's resource in the plugin jar and
written under the plugin's data folder.Deprecated.
NBT config parsing was removed in v5.
Was a record.
Interface for classes that accept
See
ConfigObserver registrations.See
ObservableConfig.registerConfigObserver(ConfigObserver).This Menu class focuses on providing a simple menu that allows for only one single click per opening.
Utility class for loading a
OneClickMenu.Builder from a ConfigurationSection.A container for all the options that every
Use Getters and Setters to access and modify these options.
OneClickMenu must allow to be configured.Use Getters and Setters to access and modify these options.
This Menu class focuses on providing an easy way of creating a menu with multiple pages.
Utility class for loading a
PaginatedMenu.Builder from a ConfigurationSection.A container for all the options that every
Use Getters and Setters to access and modify these options.
PaginatedMenu must allow to be configured.Use Getters and Setters to access and modify these options.
Utility class to paginate a list of objects.
Represents the layout of a
PaginatedMenuThis is just a helpful class to store an object of two objects.
One declared argument of a
KamiCommand, pairing a Type with a display name and an optional
default value.Do not implement this outside KamiCommon. This was a
sealed hierarchy until
spigot-utils dropped to Java 8 so that 1.8.x servers could load it; sealed is Java 17
and has no Java 8 spelling.Represents the type of operation to be performed in a patch.
VALUES:
- ADD: Adds a new element or modifies an existing one.
- REMOVE: Removes an existing element.
VALUES:
- ADD: Adds a new element or modifies an existing one.
- REMOVE: Removes an existing element.
Utility class for helping with players
You can give items (which drop near them if they are full), and clean their inventory (with or without armor)
Some basic preconditions for when the Google preconditions are not available on the classpath
Represents a
MenuIcon, but with an additional priority value# Introduction
PS stands for PhysicalState.
A
Requirement that passes when the sender holds a permission node, obtained with
RequirementHasPerm.get(String) and attached with KamiCommand.addRequirements(Requirement...).A
Requirement that passes only for a Player sender, so a command carrying it can never run
from console.This Menu class focuses on providing a simple single-frame menu.
Utility class for loading a
SimpleMenu.Builder from a ConfigurationSection.A container for all the options that every
Use Getters and Setters to access and modify these options.
SimpleMenu must allow to be configured.Use Getters and Setters to access and modify these options.
Represents the simplest layout for a
This layout is defined by: A 1 block gap (border) at the top of the menu where no items are placed. A 1 block gap (border) at the left and right of the menu where no items are placed. The last row is reserved for the pagination controls. The second to last row is also a gap (border) row, such that the remaining rows in between are used for the page items. NOTE: This layout only supports menu sizes that have at least 4 rows.
PaginatedMenu.This layout is defined by: A 1 block gap (border) at the top of the menu where no items are placed. A 1 block gap (border) at the left and right of the menu where no items are placed. The last row is reserved for the pagination controls. The second to last row is also a gap (border) row, such that the remaining rows in between are used for the page items. NOTE: This layout only supports menu sizes that have at least 4 rows.
A utility class for soft PlaceholderAPI integration
This class will utilize PlaceholderAPI if it is present on the server, safely ignoring replacements if it is not.
This class will utilize PlaceholderAPI if it is present on the server, safely ignoring replacements if it is not.
A class that represents a configuration file (Meant for implementations WITHOUT a JavaPlugin object available)
If you have a JavaPlugin object, it is recommended to use @KamiConfig instead
This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
If you have a JavaPlugin object, it is recommended to use @KamiConfig instead
This is an extension of a YamlConfiguration, so all get, set, and put methods are available.
StandaloneConfig but with some extended featuresA stateful modifier for an icon's
The
ItemBuilder it wants to place in a menu.The
StatefulIconModifier.modify(ItemBuilder, ItemStack, Player, int) method also provides the existing item in the menu (if it exists) and the Player viewing the menu.A static modifier for an icon's
ItemBuilder it wants to place in a menu.A
Supports ONLY read operations.
ConfigSource implementation that reads from a predefined yaml string in memory.Supports ONLY read operations.
Utility methods for working with text strings.
Static helpers for rendering a duration and for resolving a wall-clock time to a
Date.A boolean that can also be absent, for a setting that is explicitly true, explicitly false, or simply not
configured.
This is just a helpful class to store an object of three objects.
Static text helpers used throughout the command framework: joining collections, splitting camel case,
prefix filtering for tab completion, turning enum constants into display names, and building the centred
"titleized" lines that head command output.
Converts one command argument into a
T and supplies the tab completions offered for it.The base for every
Type, supplying a display name derived from the class name, identity and
equality helpers, and prefix filtering of tab completions.A
Type base for values drawn from a known set, adding exact, case-insensitive and Levenshtein
matching over that set along with the "no match" and "ambiguous" errors configured on TypeAbstractChoice.Config.Message and Color configuration for TypeAbstractChoice chat responses.
A
Type base for parsing that signals failure by throwing.The base for the numeric types, each parsing through its own wrapper's
parse method so that a
non-numeric or out-of-range argument fails with the standard "is not a number" message.A
TypeAbstractException that replaces the thrown exception's message with a uniform one reading
"x" is not a <type name>.The base for the boolean types.
A
Color parsed either from three space-separated components in the range 0 to 255, or from a
six-digit hex string that may be prefixed with #.A
Date parsed strictly as yyyy-MM-dd, carrying no time of day and offering no tab
completions.An
Enchantment matched against its common name as well as its Spigot key, so that both
"Fire Protection" and "PROTECTION_FIRE" resolve to the same enchantment.The base for types backed by a Java enum, matching an argument against the constant names
case-insensitively and offering those names as completions.
A
Material matched by constant name.A namespaced key as a lowercased
String rather than a Bukkit NamespacedKey, defaulting to
the minecraft namespace when the argument contains no colon.Represents a OfflinePlayer seen before by this server, accessible through the Bukkit API via UUID.
A
Permission matched against those currently registered with the
PluginManager, so a node that no plugin has declared never resolves.Represents a Player currently logged into this server, accessible through the Bukkit API.
An
Integer constrained to a range, built per range with TypeRange.get(int, int) rather than shared.A
CommandSender, resolved from the console's reserved id, or from a UUID or the exact name of an
online player.The raw argument, passed through unchanged.
The raw argument passed through unchanged, as
TypeString does, but named "confirmation text" so
that a usage template reads as a prompt to retype something.A time zone identifier as a
String rather than a TimeZone, matched against
TimeZone.getAvailableIDs().A
UUID parsed from its standard string form, or a freshly generated random one when the argument
is "random".A
World matched by name against the worlds currently loaded on the server, so a world that is not
loaded never resolves.An
XMaterial matched by constant name, giving one identifier that resolves across server versions.This command is used to log unmatched arguments.
ComponentMenuTitleProviderusingVersionedComponent