All Classes and Interfaces
Class
Description
A module configuration bound through the converter registry and a comment-preserving document.
One setting, or one entry of a map setting, the module changed since the last load or save: where it is in the
file, what the module holds there now, and what the framework last read or wrote there.
A batch initialization write: what to insert, and the bytes it was read from (#602).
Where
AbstractConfigEntity.insertKeysIn(com.ultikits.ultitools.config.document.ConfigDocument, java.lang.reflect.Field) puts a setting, and the dotted section it belongs to (named in a refusal).A detached raw entry acknowledgment; absent and explicit null are different states.
Abstract class representing a console command executor.
Abstract class representing a player command executor.
Abstract base class for relational database data operators.
Materialises the current row of a result set as an entity; see
AbstractRelationalDataOperator.getRowMapper().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.
The only way the config storage layer replaces a file.
The file-system steps of a write and a load, as a seam for fault-injection tests.
A backup this server run wrote, and the SHA-256 of the bytes it wrote there.
Thrown when an in-place write failed after the target was opened and putting the target back from its framework
backup failed too (#622): the target may hold part of the new content, and the backup holding its previous content
is kept.
A temporary file written beside its target and not yet moved over it.
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.
Bukkit-owned serialization and world identity, without inspecting server implementation fields.
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.Turns a module's
CodeSource.getLocation() URL into the File it names -- the one
resolver the language subsystem uses, so language discovery (Localized.supported()), the
dictionary reader and resource extraction in UltiToolsPlugin can never disagree about
where a module's JAR (or exploded class directory) is (#676 case 26).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 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.
How a
WhereCondition compares a stored column with its value.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.
Converts one Java value type to and from the configuration plain-data model.
Registers a converter discovered in a module's scan packages, before config initialization.
One config file as a document: SnakeYAML's own node tree (comments, quoting and layout as they are in
the file) plus the plain-data view of its values, addressed by key arrays.
One comment line to re-indent: where the reader found it, and what must be there for the move to apply.
The two comment placements adjusted on read (see the class description).
A section left with no value that a
ConfigDocument.set(java.util.List<java.lang.String>, java.lang.Object) made a section again, and the comment lines indented under it.A
SafeConstructor that constructs single nodes and flattens merge keys on request.Builds the plain-data view of a composed tree with Bukkit's key and value rules.
Builds new nodes for plain values.
Utility class for configuration editor operations.
Config entity annotation.
Config entry annotation.
Thrown when an operator's map-entry write made under an
EntryPresence condition was not written because the
condition did not hold: the entry is already in the file under EntryPresence.MUST_BE_ABSENT, or it is no
longer in the file under EntryPresence.MUST_BE_PRESENT.What reading one config file found.
The four outcomes of a load.
Thrown by
ConfigDocument.parse(String) when a config file's text is not a document this layer
reads: a YAML syntax error, a global tag such as !!java.util.UUID, a top level that is not a
mapping, or nesting deeper than the limit.Deprecated, for removal: This API element is subject to removal in a future version.
Configurable data operation interface.
Configuration annotation to replace Spring's @Configuration.
Exception thrown when configuration operations fail.
Thrown when an explicit configuration write - an operator's change written through
AbstractConfigEntity#saveOperatorChange, AbstractConfigEntity#saveOperatorMapEntry or a panel edit - is
refused by the framework's configuration write gate, so that nothing was written.Makes the panel's log stream a mirror of the server console (as of 6.3.0).
Marks the current thread while Paper's forwarder copies a record into Log4j.
The appender on Log4j's root logger.
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.
Immutable conversion location, with recursive dispatch through the same module registry.
Checked conversion failure carrying the file, whole key path, and declared Java type.
One refused nested input, retained independently of the successfully converted values.
Internal converted value and all nested diagnostics collected during that conversion.
Type resolution for reflective declarations, generic ancestors, bounds, and arrays.
Module-local converter lookup and pre-file type validation.
Outcome of
ConverterRegistry.Context.probe(java.lang.Object, java.lang.reflect.Type): whether the read succeeded without any failure, and the value it read.Validates and manages command cooldowns for players.
An executor-scoped cooldown key (#539): the executor instance, compared by identity and held
weakly so an active cooldown never keeps an unloaded module's executor -- and with it the
module's class loader -- reachable, plus
method.toString().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.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConfigConverter and
ConfigConverterFor; removed in the next version.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.
The layout facts of one config file that SnakeYAML's emitter needs to write the file the way it already
looks.
One pass over the composed tree, recording the first occurrence of each layout fact.
Holds the log records written between
UltiTools#onLoad() and the moment the panel's log
stream starts (LogStreamManager#initialize), so they reach the panel too (#487).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.
The condition an operator's map-entry write is made under: whether the entry must already be in the configuration
file, or must not be, when the write happens.
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.
One handler
EventBus.releaseForSupersede(UltiToolsPlugin) removed, and where it stood.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.
The result of
FileOperationManager.resolveTarget(String, ResolveMode): the final decision and, when it
is allowed, the operand the handler performs I/O on and that operand's mapped
server-root-relative path.How
FileOperationManager.resolveTarget(String, ResolveMode) treats the request's terminal component.A request shape that cannot be located safely; always becomes a non-configurable refusal.
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.Resolves the framework's own operator-, player-, panel- and e-mail-facing text through the
language catalogue (
lang/en.json, lang/zh.json), so it follows the server's
language setting.Game mail service interface for in-game mail system.
Type parser for Bukkit GameMode.
Generic factory categories, their construction policy, and per-element diagnostic boundaries.
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.The file an entity id names in a JSON table directory,
<table directory>/<id>.json, and
the rules an id must meet before an insert creates that file (question 12 A of the Phase 20.4
decisions).Resolves a file name against a directory; replaceable in tests.
The durable state shared by every JSON table of one identity (a plugin, an external data folder,
or one directly constructed operator): its redo journal, the sequence numbers its records draw
from, the commit gate, the checkpoint mutex, the registry of its operators and the generation
counter behind their dirty marks (20.4-RESEARCH.md section 12.7).
One dirty key captured by a checkpoint: its generation and its committed value, or
null if deleted.A test callback for the named checkpoint steps.
The redo journal that makes a multi-file JSON commit crash consistent (20.4-RESEARCH.md
section 12.7).
Forces a directory's entries to disk; replaceable in tests.
One change of a record: an entity file to write with its after-image, or to delete.
What a record stands for.
Moves a file; replaceable in tests.
A committed record read back from the journal directory.
A record file found in the journal directory.
A test callback for the named journal steps.
The table write locks of the JSON backend: one per
JsonStore, shared by every operator
the store hands out (an operator constructed directly keeps its own).The owning thread of one table and how many holds it has on it.
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.One JSON transaction's staged writes: for every
SimpleJsonDataOperator the transaction
has written, an overlay of staged puts and deletes, kept in first-touch order.One operator's staged writes, keyed by the key the operator's committed entries use.
One staged write: a detached value to put, or
null for a delete.A test callback for the named steps of a commit.
The
TransactionManager for the JSON backend, giving @Transactional and
DataOperator#transaction(...) on datasource.type: json the same propagation
behaviour DataSourceTransactionManager 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.
Frozen legacy parser semantics behind a detached input and explicit plain-output boundary.
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 search 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 an attribute, with the annotation instance that declared it, that
instance's distance from the class (0 = declared on the class), and the declaring attribute's
name (for conflict messages).
One annotation instance reached by
MergedAnnotationResolver.findNearest(java.lang.Class<?>, java.lang.Class<? extends java.lang.annotation.Annotation>, java.util.Set<java.lang.Class<? extends java.lang.annotation.Annotation>>), linked to the one it was found on.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.
Which module API levels
/upm installs from a catalogue.Base class for all module events.
Marks a method as a module event handler.
The files of the module subsystem and the transactions that change them: which folder modules
load from, and how
/upm update replaces a module's JAR (#505, #513).Where the latest version of a module, and its download, come from.
Named points of a transaction; a test crashes at one to reproduce that window.
How a JAR is downloaded.
A file a destructive step touches, and the recorded hashes it may hold; none means it must be absent.
How files are moved and deleted; a test substitutes a failing one.
File work that may fail with an
IOException.The catalogue keys of every line this class produces.
A step found a file the transaction cannot identify; the record is held for the operator.
Thrown by
ModuleFileTransactions.Catalogue.latestVersion(java.lang.String) when the catalogue answers that versions of the
module exist but none is compatible with this framework's API level (HTTP 409 from the
level-filtered latest; plan 18-40), so staging can say so instead of "no download".The persisted record of one transaction.
What
ModuleFileTransactions.recordedIdentity(com.ultikits.ultitools.utils.ModuleFileTransactions.Removal, java.io.File) found: the same file, a different file, or -- with the read
error -- a file whose content could not be read to tell.A record whose names would leave their folder, or that this version does not understand.
One file a
REMOVE record deletes at the next start, and what it was when recorded.A module an uninstall removed, in every form a transaction can name it by: the
identify-strings and runtime names of the instances it unloaded (plus the argument it was
given), and the file names of its JARs -- the ones those instances were loaded from, the ones
the start-up scan recorded as declaring their main class, and the ones it deleted or recorded
for deletion.
One line for the start-up log, with its catalogue key and arguments.
What
ModuleFileTransactions.reserve(com.ultikits.ultitools.utils.ModuleFileTransactions.Record, java.io.File, java.lang.String, java.util.List<com.ultikits.ultitools.abstracts.UltiToolsPlugin>, java.util.function.Function<com.ultikits.ultitools.abstracts.UltiToolsPlugin, java.io.File>) decided: the module and JAR to stage an update for, or the refusal.Which start-up step a rollback is finished from; it decides what the log line says.
The outcome.
Which JARs in the modules folder declare which module main class, as the module loader read them
at start-up (#516).
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.
Declares that a config value must not be empty.
Notification service interface
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConfigConverter and
ConfigConverterFor; removed in the next version.What the framework and its modules share about official language files (#608).
Logs why a framework language file was not replaced; the file stays as it was in every case but one.
Completer that suggests online player names.
Writes named keys of an operator-editable YAML file that a module manages on an operator's behalf - a kit file, a
menu file - and nothing else.
A file's text exactly as
OperatorFiles.read(File) found it, and the fingerprint of its bytes.What
OperatorFiles.write(Snapshot, Map) did.The write gate for operator-editable config files: the one way the framework changes such a file
automatically (maintainer decisions of 2026-10-04: "operator-written configuration is never overwritten
automatically" and "what code may write, by file type").
The owned paths the edit actually changed: values (inserted, set or removed) and comments.
The sections an insert finds empty (#620, #610 item 2).
What a write did.
The outcome of one write, its one-phrase reason, and the document now on disk when there is one.
One side of the comparison: its document, node tree, lines, nodes by line and owned-line marks.
The file as the gate read it at write time, or why the write cannot start.
A verified write whose content is staged and not yet published - or, when nothing needed staging, the write's
settled result.
The steps of a gated write that call into the YAML library, as the fault seam names them.
What one write through
OperatorFileWriter may change in a config file: the value paths it sets,
inserts or removes, the paths whose comment lines it rewrites, or - only when the file does not exist yet -
the whole file.Collects owned paths; each path is copied, so later changes to the caller's list do not leak in.
Utility class for package scanning and class discovery operations.
Writes the framework's lines about the panel connection itself to the server console, marked so
the panel's log stream never sends them back to the panel (as of 6.3.0).
The mark: a record of this type is a panel-connection line.
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 with the module name that registered it and,
when the registration named one, the module instance (#506).
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConfigConverter and
ConfigConverterFor; removed in the next version.Validates that a text config value - a
String, or a char matched as a one-character string (since
6.3.0, #631) - matches the specified regular expression.Validates that the command sender has the required permission.
The plain-data boundary of the config storage layer.
Explicit normalization of legacy/Bukkit output containers, never a reflective object walk.
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.
A catalogue answer whose
data is a string, with its HTTP status kept.What one entry of the modules folder is, relative to the module being uninstalled.
The reasons, as catalogue keys (Chinese, with their English values in
lang/en.json); a nested Keys holder like ModuleFileTransactions.Keys.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".
What the module loader and the loaded instances say about an uninstall's targets, read before
anything is unloaded.
The uninstall could not delete these JARs now -- the running server holds them open, or the
folder is not writable -- and has recorded them, so the next start deletes them before any
module loads (#518).
The uninstall could not delete these JARs now and could not record their deletion for the next
start either (#518).
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.
Forwards the records of a dedicated diagnostics logger to the framework's own plugin logger, so they
reach the server console at their real level and in the server's normal log format (#557).
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 needs: its declared
name: and main: (both nullable - absent when the archive has none or
reading failed), its loadAfter: list, and its Bukkit-level softdepend: /
depend: lists (all three never null; empty when absent or reading failed), and its
declared version: and api-version: as text (both nullable, like name and
main), which the load-failure refusal quotes to identify the module.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.What a module's reload did not manage to do (#529).
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(boolean) 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.
A data operator that can report how many rows a delete by id actually removed (#521).
Marks a
@CmdMapping method body as eligible to run off the main thread -- see below
for when that is, and is not, actually safe.Exact scalar conversions; numeric decisions never narrow through a double cast.
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.
One physical line that defines a key, located with the
Properties grammar.The file's bytes and its text as the server decodes them: strict UTF-8, or ISO-8859-1 when the bytes are not
valid UTF-8 (Paper 1.21.11
Settings#loadFromFile, measured from the server jar).Outcome of one
set_all batch.What actually happened to one key.
An outcome, and for a refusal the reason (no value).
Service annotation to replace Spring's @Service.
Simple dependency injection container to replace Spring ApplicationContext.
One by-type candidate as
SimpleContainer.describeCandidates(Class) sees it: a name, the existing
instance if there is one, and the class its priority is read from.Simple HTTP client implementation using HttpURLConnection.
Simple Json data operator.
Simple temp listener.
Validates that a config value's size lies 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.
Deprecated, for removal: This API element is subject to removal in a future version.
Use
ConfigConverter and
ConfigConverterFor; removed in the next version.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.
One key's registration: the completer and the owner it was attributed to, replaced and
removed as a unit.
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.
Performs an authenticated UltiCloud request on a module's behalf, without ever handing the module
the server's UltiCloud token.
What happened to a request.
The result of one call: an
UltiCloudRequests.Outcome, and for a completed exchange its status and body.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.
A custom language file as last parsed for comment recognition;
language is null when unreadable.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.
The answer to one catalogue version lookup, as the start-up update check needs it: a version was
found, the catalogue confirmed it has nothing to offer, or the lookup failed (the catalogue could
not be reached, answered with an error status, or sent a body that could not be read).
What the lookup established.
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.
ConfigConverterandConfigConverterFor; removed in the next version.