All Classes and Interfaces
Class
Description
Abstract class representing a configuration entity.
Abstract class representing a console command executor.
Abstract class representing a player command executor.
Abstract base class for relational database data operators.
Abstract class representing a tab command executor.
The reason-carrying return type both remote-surface policy predicates change to as of 6.3.0:
CommandExecutionManager's command-allowed check and FileOperationManager.isPathAllowed
both previously returned boolean.AliasFor annotation to replace Spring's @AliasFor.
Memoizes the two annotation lookups in
AopAdvisor for one annotation type.Utility class for annotation processing operations.
An advisor that combines a pointcut (when to apply) with advice (what to do).
Internal implementation for annotation-based advisors.
Decides whether a class can be proxied, and explains why not when it cannot.
A single reason a class cannot be proxied.
The category of the problem.
The five proxy-eligibility rules, unified per D-36.
Decides which class the container should instantiate for a bean.
Applies an advisor's interceptor only to the methods that advisor matches.
Simple rate limiter for UltiCloud API calls.
Generic wrapper for backend API envelope responses.
Annotation to mark a command method as async execution.
Data entity with audit fields for tracking creation and modification.
Autowired annotation to replace Spring's @Autowired.
Simple autowire factory to replace Spring's AutowireCapableBeanFactory.
Base command executor with improved architecture using Chain of Responsibility pattern.
Base class for confirmation dialogs with OK and Cancel buttons.
Builder for creating confirmation dialogs.
Enhanced abstract data entity with generic ID type and lifecycle hooks.
Base class for inventory GUI pages with common functionality.
Base class for paginated inventory pages.
Base service interface.
Basic type determination utility class.
Bean annotation to replace Spring's @Bean.
Bean copy utility class.
Bean definition to hold metadata about a bean.
Simple bean factory to replace Spring's BeanFactory.
Bean post processor interface to customize bean initialization.
BuildContext carries the contextual information available while building a Widget tree.
Builder for BuildContext.
The enum Buttons.
Cacheable data operation interface.
Interface for events that can be cancelled by handlers.
The panel-facing remote surface, sliced into eight independently-switchable capabilities plus
the
Capability.NONE sentinel for protocol-level messages.Manager for chat-based callback commands.
A chat-based confirmation dialog implementation.
Utility class for ensuring proper class loader usage throughout the plugin.
GEN-07's observe-only classload filter audit (D-14): reproduces the exact matching semantics of
the three name-based filter layers
SecurityPolicy.isSafeClassName(String) used to
enforce before D-12/D-13, and records what each removed layer WOULD have refused -- it refuses
nothing itself.The four removed filter layers, in the exact order
isSafeClassName evaluated them.The three command-facing entry points behind
/ulticloud login|logout|status.An immutable view of
CloudAuthManager.status()'s result.Commands for UltiCloud authentication via magic link.
The single owner of one UltiCloud login's entire lifetime.
Marks a
@CmdMapping method as subject to a per-player cooldown.Command executor annotation.
Command mapping annotation.
Command parameter annotation.
Command sender annotation.
Command suggest annotation.
Command target annotation.
The single implementation of
@CmdTarget's class-versus-method composition rule.How a method-level
@CmdTarget value relates to the class-level one.Column annotation.
Immutable command execution context containing all information about a command invocation.
Exception thrown when command execution or validation fails.
Command execution manager.
Command output capture.
Command result data class.
Command manager.
Single tab-completion dispatch implementation originally shared by both command-executor
generations (WIRE-01 / D-06);
AbstractCommandExecutor was removed in 6.3.0, so
BaseCommandExecutor is now this class's only caller.Interface for command validation following the Chain of Responsibility pattern.
Result of a validation operation.
Common utility class providing general-purpose helper methods.
Comparison operator enum class.
Component annotation to replace Spring's @Component.
ComponentElement is the base Element class for Elements that hold a child Widget.
ComponentScan annotation to replace Spring's @ComponentScan.
Component scanner to find and register components.
Conditionally registers a component based on a YAML config value.
The single shared
@ConditionalOnConfig registration decision (D-17).Thrown by
ConfigBindings.Source.reloadSource() when the bound entity's last reload failed, so the
@CmdCD reload step can keep the running value and say why.A resolved binding: the module's config entity and the
@ConfigEntry field a key
names.Framework-internal access to the config-bound
@CmdCD state an executor carries (#531):
the resolved seconds of its bound cooldowns and their load-time value sources, both keyed by
CooldownValidator.bindingKey.Listener interface for configuration changes.
Utility class for configuration editor operations.
Config entity annotation.
Config entry annotation.
Configurable data operation interface.
Configuration annotation to replace Spring's @Configuration.
Exception thrown when configuration operations fail.
Container is a widget that can hold multiple child Widgets.
Builder for Container.
The Element counterpart of Container.
Exception thrown when IoC container operations fail.
Marker configuration class for the framework's own context.
Context entry annotation.
Validates and manages command cooldowns for players.
The single owner of
data.json. Any other class that opens a reader or writer on
that file is a defect (D-12) -- route the operation through CredentialStore.read(), CredentialStore.write(Map)
or CredentialStore.update(UnaryOperator) instead.The outcome of a
CredentialStore.read() call.Exception thrown when data access operations fail.
Data operation interface.
A framework-issued credential identifying the caller of a
DataStore
method.DataSource-based implementation of
TransactionManager, and its JDBC-specific
sub-interface JdbcTransactionManager.Internal class to hold transaction state.
Data storage interface.
Data store manager.
DeclarativeGui is the base class of the declarative GUI framework.
Default implementation of EmailService using JavaMail.
Dependence managers.
Utility class for handling plugin dependency and package scanning operations.
DiffResult represents the difference between two renders.
Builder for DiffResult.
Represents a single node move.
Represents a single node update.
Internal economy-provider seam behind
EconomyUtils.The three states an economy request can be in, named so the operator-facing message can
distinguish them (D-08): a missing plugin is not the same problem as a missing provider.
Utility class for economy operations using Vault.
One frame's match outcome: the
EconomyUtils.MatchKind, plus the resolved module name when (and
only when) kind == RESOLVED.The three possible outcomes of matching one stack frame against
prefixToModule
(Codex P2, PR #463, round 3): a bare null return collapsed "this frame belongs to no
registered module" and "this frame's closest root is claimed by two or more DIFFERENT
modules" into the same value, and the last two review rounds both found a defect that traces
straight back to that conflation — a NONE frame must let the per-frame walk continue
outward (a real non-match, no evidence either way), while an AMBIGUOUS frame must
terminate the walk immediately (real evidence that a module frame exists here, but WHICH
module cannot be determined) — see EconomyUtils.attributeModule(StackTraceElement[], Map)'s own
javadoc for why continuing past an ambiguous frame is itself the bug.Element is the instantiated representation of a Widget, responsible for managing the Widget's
lifecycle and updates.
Email service interface for sending emails via SMTP.
Enable auto register annotation.
Type parser for Bukkit Enchantment.
Error codes for UltiTools exceptions.
Collects, deduplicates, and rate-limits error reports before they reach the WebSocket.
Error report data structure.
Central event bus for inter-module communication.
Event listener annotation.
Priority levels for module event handlers.
Annotation to mark methods or classes for automatic exception catching.
Interface for custom exception handlers used with
ExceptionCatch.AOP interceptor that handles @ExceptionCatch annotated methods.
Exponential backoff reconnection strategy.
Builder for ExponentialBackoffStrategy.
Wraps a regular Bukkit
JavaPlugin to provide the information
UltiTools framework needs for annotation scanning, IoC, and data storage.File operation manager.
File operation utility class.
Marks a type as non-extendable, or a method as non-overridable, without using the
final
keyword.Enforces the
Final contract when the framework loads a module's classes.Game mail service interface for in-game mail system.
Type parser for Bukkit GameMode.
GridView is a grid-layout Widget that arranges its children in a grid.
Builder for GridView.
The Element counterpart of GridView.
GuiRenderer is responsible for coordinating Widget tree construction, diffing, and Inventory
updates.
GuiScheduler is responsible for ensuring every GUI operation runs on the Bukkit main thread.
Internal representation of a registered event handler.
A multi-line hologram widget using invisible ArmorStands.
Utility class for HTTP file download operations.
Progress callback interface for download operations.
Utility class for HTTP request operations.
I18n annotation.
IconWrapper is a simple wrapper around Icon, used to pass it through the Widget tree.
Builder for IconWrapper.
Teleport service implementation.
Result object for delay teleport tick processing.
Result object for BossBar tick processing.
A GUI inventory-based confirmation dialog implementation.
Plugin interface.
Enum representing transaction isolation levels.
ItemDisplay is a Widget that displays an item.
Builder for ItemDisplay.
The RenderObjectElement counterpart of ItemDisplay.
A fluent builder for creating ItemStacks with various properties.
Utility class for ItemStack serialization and deserialization.
JDBC-specific extension of
TransactionManager.JSON path utility class - replaces hutool-json's putByPath/getByPath functionality
Json Data store.
Composite operator-cache key: the requesting identity (plugin name on the plugin path,
canonical data-folder path on the external
File path) plus the entity class.Snapshot-based
TransactionManager for the JSON backend (D-03), giving
@Transactional the same consistent behaviour on datasource.type: json that
DataSourceTransactionManager already gives the two JDBC backends.Internal class to hold JSON transaction state -- the JSON analogue of
DataSourceTransactionManager.TransactionContext, minus anything JDBC-specific.Language entity class.
Listener manager.
Localized interface.
Type parser for Bukkit Location.
Log stream manager.
Parsed, validated
batchConfig section; each field is null when not present in the request.Parsed, validated
levels section of a config-update request; LogStreamManager.LevelsSection.present is false if absent.Completer that suggests Minecraft material names.
General merged-annotation resolution: a recursive walk of the whole annotation tree, with
explicit meta-annotation attribute override via
AliasFor.One attribute's declared
@AliasFor target, for reciprocity checking.One candidate value for a target attribute, plus where it came from (for conflict messages).
Message utils.
AOP method interceptor interface.
Represents a method invocation that can be intercepted.
Completer that invokes suggestion methods annotated with @CmdSuggest.
The signature shapes
MethodInvocationCompleter.invokeSuggestMethod(TabCompletionContext, Method) knows how
to invoke a @CmdParam.suggest() method-name target with.The result of one
ReflectionUtil.getAllMethods(Class) hierarchy scan, together with the
bean class it was scanned for.An extremely simple JSON builder.
A super simple representation of a JSON object.
Base class for all module events.
Marks a method as a module event handler.
Turns a silently-skipped class from a module's startup scan into a single, named, loud line an
operator actually reads (D-19).
MySQL implementation of the data operator.
MySQL-backed
DataStore.Composite operator-cache key: the requesting identity (plugin name on the plugin path,
canonical data-folder path on the external
File path) plus the entity class.The Navigator Widget.
The state class for Navigator.
A Connection wrapper that suppresses
NonClosingConnectionProxy.close() during transactions.No-op implementation of GameMailService.
Validates that a String config value is not null or empty (after trimming).
Notification service interface
Interface for serializing objects to Bukkit configuration MemorySection.
Completer that suggests online player names.
Utility class for package scanning and class discovery operations.
Published once for every inbound panel message the framework has already handled — appended as
the very last statement of
PluginInitiationUtils#handleInboundMessage(JsonObject), after
the framework's own dispatch has completed.The single-owner registry a module uses to claim a request/response responder for a panel
message type the framework itself does not own (WIRE-16, D-26/D-27).
An immutable pairing of a responder function and the module name that registered it.
Generic parser interface for serialization and deserialization.
Validates that a String config value matches the specified regular expression.
Validates that the command sender has the required permission.
Marks a field for automatic cleanup when a player quits.
Manages automatic cleanup of @PlayerCache-annotated fields when players quit.
Opt-in contract for a tracked instance that also carries time-based (as opposed to
player-quit-based) state to prune.
The three field shapes
PlayerCacheManager.registerBean(Object) can sweep.Optional interface for services with @PlayerCache(saveBeforeRemove = true).
Player event manager.
Declares plugin dependencies for UltiTools plugins.
Plugin dependency resolver using Kahn's algorithm for topological sorting.
Exception thrown when circular dependencies are detected.
Exception thrown when required dependencies are missing.
Represents a dependency graph node containing plugin class and its dependencies.
Utility class for plugin initialization and WebSocket communication.
A dispatch-table entry pairing a handler with the
Capability that must be enabled
before it runs (D-10), and with which side records that decision's verdict in the
RemoteActionLog (CR-01, 06-REVIEW.md).Which side of a capability-gated dispatch records the
RemoteActionLog verdict for
the enabled branch (CR-01, 06-REVIEW.md).Utility class for plugin installation and management operations.
Raised when the name the operator typed could be more than one loaded module's, so the
uninstall changed nothing.
What one archive says about which module it holds -- the single reader both identity
resolution and entry classification use, so the two cannot drift apart.
What one entry of the modules folder is, relative to the module being uninstalled.
Everything later decisions need about which module this is, resolved once.
Raised when a module's own unload threw.
What a filesystem probe answered, keeping "unknown" out of "no".
The entries an uninstall could not identify, carried on whatever failure leaves the method.
Raised when the uninstall refuses to act because its outcome would be undefined: two possible
targets, or a target whose JAR another running module shares.
What an uninstall did, and what it could not determine.
UltiTools plugin manager.
Exception thrown when plugin module operations fail.
Reads a module's own
plugin.yml straight from its class's code source, given only a
bare Class<?> - before any UltiToolsPlugin instance exists (D-12).The subset of a module's
plugin.yml this framework's dependency graph needs: its
declared name: (nullable - absent when the archive has none or reading failed) and
its loadAfter: list (never null; empty when absent or reading failed).Shared implementation of the "replace a file in place, preserving what the operator set up"
operation used by every
createTempFile + atomic-Files.move(java.nio.file.Path, java.nio.file.Path, java.nio.file.CopyOption...)
replace-in-place site in this framework.Callbacks a
PosixAttributePreserver.replaceInPlace(java.io.File, byte[], com.ultikits.ultitools.utils.PosixAttributePreserver.ReplaceInPlaceListener) caller supplies so each replace-in-place site can log
accurate, resource-specific wording for exactly how the operation was declined or degraded
-- this shared operation does not know or care whether target is a language
catalogue or a provenance sidecar, only the caller does.Marks a method to be called after dependency injection is complete.
Marks a method to be called before the bean is destroyed.
Enum representing transaction propagation behaviors.
Factory for creating inheritance-based subclass proxies.
Dispatches intercepted calls to the
MethodInterceptor chain.Marks a generated proxy class and names the target class it proxies.
Fluent query builder for data entities.
Default implementation of
Query that wraps a DataOperator.Simple functional interface for in-memory filtering (Java 8 compatible).
Validates that a numeric config value falls within the specified range.
Strategy interface for WebSocket reconnection behavior.
Reflection utility class.
Implementation of
MethodInvocation that uses reflection to invoke methods.The framework's own durable record of what the panel actually did — every capability-gate
decision, allowed or denied, as one JSON line in the active file under
plugins/UltiTools/security/action.log.<generation>.One immutable action-log entry.
Serializes one
RemoteActionLog.Entry per LogRecord into a single compact JSON line — no
pretty-printing — using the same GsonBuilder().disableHtmlEscaping() construction the
WebSocket managers already use.Allowed or denied — the two verdicts a capability gate can reach.
Raised by
RenderDepthGuard when one of the declarative render frame's traversal
recursions reaches an Element-tree depth beyond RenderDepthGuard.MAX_DEPTH.Shared depth ceiling for the declarative render frame's traversal family (T-05-62 / #371).
RenderNode is a node in the virtual render tree, representing one slot to be rendered.
RenderNodeDiffer implements the diff algorithm for the RenderNode tree.
The key used to identify a RenderNode.
RenderObjectElement is the Element that corresponds to a RenderNode.
RenderObjectWidget is the base Widget class for describing actual render content.
Records the SHA-256 digest of every resource file
UltiToolsPlugin.saveResources() extracts, so a later boot can
distinguish "the operator edited this file" from "an old jar extracted this and nobody has
touched it since" (#441, D-05/D-06/D-07).Route builder interface.
Marks a
@CmdMapping method body as eligible to run off the main thread -- see below
for when that is, and is not, actually safe.Marks a method for automatic scheduled execution by the framework.
Provides NO runtime constraint on class loading or reflection (GEN-07, D-12, since 6.3.0).
SecurityPolicy.isSafeClassName(String) and SecurityPolicy.isSafeParameterType(Class) now unconditionally
return true; SecurityPolicy.addTrustedPackage(String) and SecurityPolicy.addDangerousClass(String)
are no-ops.Validates that the command sender matches the expected target type.
Server monitor manager.
The result of one main-thread sample.
Safe server.properties manager for remote editing via WebSocket.
Outcome of one
set_all batch.What actually happened to one key.
Service annotation to replace Spring's @Service.
Simple dependency injection container to replace Spring ApplicationContext.
Simple HTTP client implementation using HttpURLConnection.
Simple Json data operator.
Simple temp listener.
Validates that a Collection or String config value has a size/length within the specified bounds.
SlotKey uniquely identifies a Widget within the Widget tree.
Slot-index calculation utilities.
The single checked-exception-safe rethrow helper for the
aop package.SQLite implementation of the data operator.
SQLite-backed
DataStore.Composite operator-cache key: the backing .db file's canonical path plus the entity class.
State is the mutable state of a StatefulWidget.
StatefulDeclarativeGui is the base class for a declarative GUI that carries state.
The Element corresponding to a StatefulWidget.
StatefulWidget is a Widget that carries mutable state.
The Element corresponding to a StatelessWidget.
StatelessWidget is a Widget that needs no mutable state.
Completer that provides static suggestions from a predefined list.
Handle returned by programmatic event subscriptions.
System log handler.
Strategy interface for providing tab completion suggestions.
Context object containing all information needed for tab completion.
Central manager for tab completion functionality.
Table annotation.
Manages scheduled tasks for plugin modules.
Per-method record of one config-bound
Scheduled task: what to invoke, where its
bound values come from, its current timing in ticks, when it was armed and last ran, and
its current Bukkit task.Teleport service.
Temporary event handler.
Temporary listener.
Create a default temporary listener builder.
TextButton is a button Widget that displays text.
Builder for TextButton.
The RenderObjectElement counterpart of TextButton.
A
QueryRunner that applies a per-statement JDBC query timeout, computed against a
shared transaction deadline rather than a fixed value (D-10 -- Spring's approach: each
statement gets the time remaining in the transaction's budget, not a fresh full
allowance).A Minecraft advancement toast notification widget.
Toast display styles based on Minecraft advancement frame types.
The only thing that writes the UltiCloud credential to disk.
Annotation to mark methods or classes for declarative transaction management.
A
DataSource wrapper that integrates with TransactionManager.AOP interceptor that implements declarative transaction management.
Interface for managing database transactions.
Immutable context describing what triggered an error.
Trigger type enum.
Exception thrown when type parsing fails.
Interface for parsing command argument strings into specific types.
Registry for type parsers.
Simple implementation of TypeParser using a parsing function.
UltiPanel log transmitter.
UltiPanel WebSocket Client
UltiTools plugin main class.
Public API for external Bukkit plugins to integrate with UltiTools framework.
The command that reloads UltiTools-API.
Base exception class for all UltiTools exceptions.
UltiTools module annotation.
Abstract class representing a plugin module.
Signals that a transaction's outer
commit() found the transaction already marked
rollback-only by a nested scope, and performed a real rollback instead of committing.Holds update information for a single plugin or the framework.
Notifies OP players about available updates when they join.
Manages version checking and update notifications for UltiTools-API and modules.
Marks a
@CmdMapping method as subject to a concurrency lock, enforced by
UsageLockValidator.Validates and manages command usage locks to prevent concurrent execution.
Manages a chain of validators that are executed in order.
Builder for creating validator chains.
Result of chain validation.
The Vault consumer bridge —
EconomyProvider's only implementation in 6.3.0 (D-08/D-09).Semantic version comparison utility class.
Utility class for version checking and comparison operations.
The enum View type.
A functional interface with no return value.
Condition class.
Widget is the core abstract class of the declarative UI framework.
Common interface for Widget builders.
Type parser for Bukkit World.
Completer that suggests world names.
Cross-version compatibility utility class using XSeries.