All Classes and Interfaces
Class
Description
An abstract foundation for multi-slot progress bars using Custom Model Data.
An abstract base class for handling batch database operations such as INSERT, REPLACE, or INSERT IGNORE.
An abstract base class representing a database connection provider and transaction manager.
Base implementation of
EnergyConductor representing a transfer-only node
with no persistent storage beyond a single-tick buffer.Base implementation of
EnergyNode providing standard storage, transfer,
and connection handling without automatic registration into EnergyNetwork.An abstract base class for multi-stop color gradients.
An abstract base implementation of a Graphical User Interface (GUI).
A base class for entities that utilize the property-based serialization system.
A fluent-style builder for programmatically creating database tables.
An abstract base class providing a fluent interface for table-level CRUD operations.
A standard foliage placer explicitly designed to generate the iconic horizontal,
layered canopy footprint associated strictly with Acacia tree typologies.
Represents the execution mode of an energy transfer operation.
Represents the result of an event or action handler.
Represents a custom advancement within the AbyssalLib framework.
Builder class for creating Advancement instances.
Represents a logical condition that a player must fulfill to progress in an advancement.
Defines the visual representation of an advancement in the client menu.
A fluent builder class for creating
AdvancementDisplay instances.Enumerates the visual border styles (frames) for advancements.
Represents a benefit or action granted to a player upon the completion of an advancement.
A tree decorator that alters the ground surface directly beneath the generated tree.
A utility class providing factory methods for time-aware
Transformer animations.Represents the context of an anvil preparation event, containing details about the player,
the items in the anvil, the resulting item, the rename text, and the repair cost.
Represents a generic resource pack asset.
Represents a definition for a custom numeric attribute.
Represents an active instance of an attribute on a specific entity.
Represents a modifier applied to an attribute's base value.
A utility class designed to programmatically generate complex, layered item models
for progress bars, health bars, and mana bars within a Minecraft resource pack.
Represents the primary axis of the bar's orientation and fill direction.
A fluent builder class used to configure and register bar models into a
Namespace.An abstract base class providing a fluent builder-style API for creating Minecraft Dialogs.
Represents a base class for dynamically rendered custom maps in Minecraft.
Handles high-performance bulk write operations in MongoDB.
H2-specific batch operation handler.
Optimized batch operation handler for MariaDB.
A MySQL-specific implementation of
AbstractBatchQuery.A PostgreSQL-specific implementation of
AbstractBatchQuery.A SQLite-specific implementation of
AbstractBatchQuery.A specialized tree decorator responsible for seamlessly attaching organic bee nest structures
directly onto the exposed horizontal faces of the generated trunk blocks bordering foliage.
A sophisticated trunk placer that generates a straight vertical column before sharply
bending diagonally towards a randomized horizontal direction.
A color provider that performs bilinear interpolation between four corner colors on a 2D plane.
A utility class for creating billboarding and orientation
Transformers.A placement modifier that filters positions based on the active biome at the coordinates.
A placement modifier that prevents feature bleeding across chunk boundaries.
An enumeration of standard digital image blending modes.
A standard foliage placer that generates a layered spherical blob of leaves.
A world generation feature that places a single block attached to a specific face
of an existing, valid supporting block.
Configuration record for the block attached feature.
An event that is called when a custom block is broken by a player.
Represents the entity data associated with a custom
CustomBlock.A placement modifier that filters out incoming positions based on the target block type.
A structure processor that prevents specific blocks from being placed.
Represents a fully self-contained snapshot of a block, including its position,
type, visual states, custom properties, and optional tile/NBT data.
An event that is triggered when a player interacts with a custom block.
A world generation feature that scatters blocks dynamically around an origin point.
Configuration record for the block patch feature.
Provides per-block persistent data stored inside the chunk.
An event that is triggered when a player places a custom block.
A sophisticated predicate used to evaluate and filter
BlockInfo instances.A fluent builder pattern class designed to easily construct
BlockPredicate instances.Utility class responsible for loading and parsing data-driven
BlockPredicate definitions.Defines the physical and interaction behavior of a custom block.
Builder for constructing
BlockProperties instances.Enum representing how a block reacts to piston movement.
Represents a blockstate JSON:
assets/<namespace>/blockstates/<id>.jsonThe base class for all block state providers.
Represents the registered type identifier for a specific block state provider implementation.
Utility class for loading written books from JSON files within a plugin's resources.
Standard
WorldGenAccess implementation using the Bukkit API.An implementation of
DynamicOps that serializes data into raw byte arrays.A placement modifier that filters positions based on a random probability.
Utility class for capturing asynchronous player chat input.
A procedural color provider that generates a 3D checkerboard pattern.
Represents the type of click interaction performed by a player.
A specialized tree decorator responsible for seamlessly attaching organic cocoa bean pod structures
directly onto the exposed horizontal faces of the generated trunk blocks.
A bidirectional serializer and deserializer capable of translating between Java objects
and various serialized formats defined by a
DynamicOps provider.An unchecked exception utilized for failures occurring during the serialization
or deserialization process.
Internal implementation for handling the
Either type, allowing for
bifurcated data structures.Represents the definition of a single field within a structured object.
Internal implementation that iterates through a list of codecs until one
successfully processes the data.
A fluent builder for executing CRUD operations on a single MongoDB collection.
An enumeration representing various types of color vision deficiencies (CVD).
A specialized utility class for converting between various color spaces.
A functional interface representing a transformation applied to a
Color.A utility class for generating various color harmony palettes based on color theory.
Represents a collection of
Color objects, providing utility methods for
color selection, palette generation, and mathematical analysis.A functional interface representing a procedural color source.
A comprehensive utility class for color manipulation, conversion, and generation.
Marks a method as a command definition for registration via the
CommandBus.A specialized map used to manage and persist
DataComponents for library objects.Represents a logical condition tree that can be evaluated against a
Predicate.A condition implementation that represents a logical AND.
A condition implementation that represents a logical OR.
A condition implementation that wraps a single value.
A wrapper for Bukkit's
YamlConfiguration that provides a fluent API,
support for Codec serialization, and manual comment injection.Represents a world generation feature strictly bound to its specific configuration.
A dialog implementation representing a binary choice, typically used for confirmations.
Represents a generic context for an event.
A placement modifier that duplicates the incoming position stream a specified number of times.
A placement modifier that duplicates the incoming position stream across every
single Y-coordinate from the bottom of the world to the top.
Defines the registration type and serialization logic for a specific
AdvancementCriterion.A wrapper for player-specific advancement progress.
Represents a custom block type in the AbyssalLib framework.
An abstract extension of Bukkit's block populator that integrates
with the AbyssalLib world generation API.
Represents a fully configurable wrapper around a Bukkit
LivingEntity,
providing extended behavior, attributes, data components, and lifecycle control.Defines spawn placement type.
Defines spawn configuration.
Builder for
CustomEntity.SpawnSettings.Custom event triggered when an
CustomEntity dies.Custom event triggered when a custom
CustomEntity is loaded into the world.Custom event triggered when a custom
CustomEntity is spawned into the world.The reason why a custom entity is being spawned.
Represents a custom damage type to be registered into the Paper
DamageType registry.A standard foliage placer explicitly designed to generate the iconic thick,
layered cuboid canopy footprint associated strictly with Dark Oak tree typologies.
Manages the connection lifecycle for a MongoDB NoSQL database.
Manages the connection lifecycle and pooling for a Redis NoSQL database.
An H2 database implementation managing local file-based storage.
A MariaDB database implementation managing remote JDBC connections.
A MySQL database implementation that handles remote connectivity, connection pooling,
and a keep-alive scheduler to prevent connection timeouts.
A PostgreSQL database implementation that manages remote connections.
A SQLite database implementation that manages the file lifecycle and connection state.
A factory utility class responsible for loading and initializing database instances.
An abstract base class representing a single piece of metadata attached to an item or block.
Represents the definition and serialization logic for a specific type of
DataComponent.Handles the loading, compilation, and registration of embedded datapacks from within a plugin JAR.
A specialized registry utility that defers object registration until the server is ready.
Static factory for generating inputs, buttons, and body content for Dialogs.
A dialog that displays a list of selectable child dialogs.
A central factory class for instantiating various dialog types.
A world generation feature that generates a flat, circular disk dynamically.
Configuration record for the disk feature.
A functional interface for mapping a BSON
Document to a Java object.A world generation feature that creates varied clusters of vertical pillars,
simulating stalactites and stalagmites.
Configuration record for the dripstone cluster feature.
Defines a set of operations for a specific serialized format (e.g., JSON, YAML, NBT).
A functional interface representing an interpolation function.
A collection of standard easing functions implemented as an enum.
A container object which may hold one of two types of values: a Left or a Right.
Represents the Left side of the
Either.Represents the Right side of the
Either.A loot function that applies a random enchantment to the generated item.
A node that acts purely as a conduit for energy transfer.
Central manager responsible for handling all energy node interactions.
Fired when energy is being transferred from one
EnergyNode to another within the network.Represents a node within the energy network capable of storing,
receiving, and providing energy.
Fired when a new
EnergyNode is being registered into the EnergyNetwork.Fired whenever the internal energy level of an
EnergyNode changes due to insertion,
extraction, or capacity adjustments.Fired when an
EnergyNode is being removed from the EnergyNetwork.Defines a serializable type of
EnergyNode.Represents a unit of energy with a conversion rate relative to a base unit.
An event called when an entity's base attribute value is changed.
An event called when a new modifier is added to an entity's attribute.
An event called when an existing modifier is being removed from an entity's attribute.
Manages custom attributes and modifiers for entities with persistent storage support.
A predicate used to evaluate and filter
SavedEntity instances based on their identity
and raw serialized data.A fluent builder pattern class designed to easily construct
EntityPredicate instances.Utility class responsible for loading and parsing data-driven
EntityPredicate definitions.A placement modifier that performs a vertical scan to find the nearest solid surface.
Represents a resource pack equipment JSON:
assets/<namespace>/equipment/<id>.json.A lightweight event bus for registering Bukkit event handlers using the
SubscribeEvent format.A loot function that reduces the amount of items in a stack based on an explosion decay algorithm.
The base class for all world generation features such as trees, ore veins, or lakes.
An interface representing the configuration parameters for a
Feature.A data container (record) provided to a
Feature during the placement phase.Utility methods for common file operations such as saving,
deleting, zipping, and hashing files or directories.
A placement modifier that completely overrides the procedural generation stream,
replacing it with a fixed, hardcoded list of specific coordinates.
The base class for all tree foliage generation algorithms.
Represents the registered type identifier for a specific foliage placer implementation.
Represents a Minecraft font resource supporting bitmap, space, TTF, and Unihex providers,
with full Unicode occupation tracking.
Represents a font glyph.
A spacing glyph that adjusts character advance.
A glyph from a bitmap texture.
TTF font provider.
Unihex font provider with size overrides.
Represents a dimensional spacing override within the Unihex font.
A trunk placer that generates a main vertical stem and sprouts diagonal branches
from its upper section.
A world generation feature that generates a contiguous, noise-driven blob of blocks.
Configuration record for the fossil feature.
A loot function that attempts to smelt the generated item stack.
Represents the chronological steps in which features are placed during chunk generation.
Functional interface responsible for defining the base geometric shape of an effect.
A utility class containing static factory methods for creating
Generator instances.A world generation feature that generates a concentric, layered geode structure.
Configuration record for the geode feature.
A trunk placer that generates a massive 2x2 vertical column of blocks.
A provider that supplies custom MiniMessage strings dynamically for translatable keys globally.
Provides integration between the translation system and named font glyphs.
A procedural color provider that generates a 2D grid pattern on the XZ plane.
Represents a template for a custom Graphical User Interface.
A fluent builder for creating Gui configurations.
A GUI element that updates its visual state based on server ticks.
An interactive GUI element that executes an action when clicked.
A context object representing the details of an inventory click interaction.
A context object representing the details of an inventory drag interaction.
Represents an interactive component within a GUI.
Flags used to configure and restrict the behavior of a
Gui.A static, non-interactive GUI element.
Defines a visual layer that can be rendered over a GUI inventory.
Central manager for handling the lifecycle and updates of custom GUIs.
Represents an active instance of a
Gui being viewed by a player.Defines the target inventory segment for rendering or interaction.
Represents head types for resource pack item definitions.
A placement modifier that snaps the Y-coordinate of incoming positions to the
highest block at that specific X and Z coordinate, dictated by a selected heightmap.
A placement modifier that randomizes the Y-coordinate of input positions
between a specified minimum and maximum bounds.
A wrapper for a registry object that enables lazy initialization and caching.
A utility class for managing and checking the status of external plugin integrations.
An enumeration of supported external plugins for which the library
provides specialized hooks.
Represents the
icon.png icon for a resource pack.A utility class for performing advanced color analysis on
BufferedImage instances.A placement modifier that spreads the input positions randomly across the X and Z axes
within the bounds of a standard 16x16 chunk.
A structure processor that applies a chance-based filter to block placement.
A wrapper enum for Bukkit's ClickType to avoid import conflicts.
Represents a custom item within the AbyssalLib framework.
Internal class used to configure the visual representation of an item's tooltip.
Represents a categorized collection of
Item instances.A fluent builder for creating
ItemCategory instances.Static factory utility for generating common Minecraft item model configurations.
A sophisticated predicate used to evaluate and filter
ItemStack instances.A fluent builder pattern class designed to easily construct
ItemPredicate instances.Utility class responsible for loading and parsing data-driven
ItemPredicate definitions.Represents the context in which an item's component is being translated.
A provider that supplies custom MiniMessage strings dynamically for translatable keys in items.
An implementation of
DynamicOps for Jackson's JsonNode tree model.A loot condition that evaluates to true only if the victim was killed by a player.
A world generation feature that generates a randomized lake or underground pool.
Configuration record for the lake feature.
Represents a language file (.lang/.json) for Minecraft resource packs.
A composite GUI layer that manages a collection of sub-layers in a stack.
A specialized tree decorator responsible for seamlessly draping organic vine structures
directly downwards from the generated leaf canopy blocks.
A loot function that clamps the stack size of a generated item within a specified minimum and maximum range.
A standard implementation of a linear color gradient.
A loot condition that evaluates to true if the loot generation occurs within specific biomes.
An abstract base class for logic gates that determine if a loot element should be processed.
A definition for a specific implementation of a
LootCondition.Immutable record containing the environment and entity data for loot generation.
Builder class for constructing
LootContext instances.An abstract representation of a single choice within a loot pool.
A loot entry that represents a "no drop" chance.
A loot entry that generates a specific item stack.
An abstract base class for functions that modify an
ItemStack generated by a loot table.A definition for a specific type of
LootFunction.A loot function that increases the stack size of generated loot based on the Looting enchantment level.
Internal utility class responsible for loading and registering
LootTables.A pool of potential loot entries within a table.
Represents a complete loot table capable of synthesizing item collections and intelligently
populating external containers using context-driven probability logic.
A root placer that generates sprawling, arching structural roots.
A loot condition that evaluates to true if the tool used in the generation context
matches a specific material.
An enumeration defining how a custom loot table should interact with existing
vanilla loot tables or other overlapping definitions.
Provides a complete utility layer for serializing and deserializing native Bukkit
BlockData and TileState instances into generic data representations
via DynamicOps.A bridge utility connecting the internal color systems with Adventure's MiniMessage.
A utility class for handling stateful text color animations.
An extension of
Pixel that includes a velocity vector.A dialog displaying multiple buttons as primary actions.
A world generation feature responsible for placing blocks that cling to solid surfaces.
Configuration record for the multiface growth feature.
Represents named colors for resource pack item definitions.
Represents a logical namespace inside a resource pack.
An implementation of
DynamicOps for Minecraft's NBT Tag structure.Implementation of
WorldGenAccess backed by NMS (Native Minecraft Server).Represents a specific permission entry or group inheritance entry.
A placement modifier that duplicates the incoming position stream a variable number
of times based on a 2D simplex noise evaluation.
A color provider that uses 3D Perlin noise to sample from a base ColorProvider.
A block state provider that alternates between two block states based on 2D simplex noise.
A placement modifier that filters positions based on 2D simplex noise.
A standard notice dialog used to display information with an optional primary action button.
A world generation feature that generates clusters of ore veins.
Configuration record for the ore feature.
A record representing a specific replacement rule for the ore feature.
Represents orientations for resource pack item definitions.
Utility for low-level packet transmission to clients.
Event fired when a packet is received from a client.
Event fired when a packet is sent from the server to a client.
A GUI layer designed for paginating generic data objects into GUI elements.
Interface responsible for the actual display of calculated particle points in the world.
A stateful controller for managing complex, animated particle effects.
Fluent builder class for
Particles.A wrapper for Bukkit's
PersistentDataContainer (PDC) API.Utility class for calculating the effective permissions of a holder based on inheritance.
Represents a group that can contain permissions and be inherited by users or other groups.
An abstract base for objects that can hold permissions and inherit from
parent nodes (typically groups).
The central authority for managing permissions within AbyssalLib.
Provides a scoped container for registering permissions under a plugin-specific namespace.
Represents a structured permission node with defaults and child relationships.
Interface defining the contract for permission data persistence.
Represents a persistent user with an assigned set of permissions and parent groups.
A world generation feature that generates a continuous vertical pillar of blocks.
Configuration record for the pillar feature.
A foliage placer that generates a conical, layered structure.
A fluent builder for executing multiple Redis commands in a single batch (Pipelining).
A specialized
Vector that carries color information.Represents a feature that is fully prepared for world placement.
Provides integration between the translation system and PlaceholderAPI (PAPI).
A record containing context information required during the placement phase.
The base class for all placement logic transformations in the world generation pipeline.
A registry-friendly type definition for a
PlacementModifier.An event called when a player's persistent statistic value is changed.
A standard implementation of a multi-slot progress bar.
A generic container for a block or entity property that supports automatic serialization.
A bridge class for accessing MongoDB collection-specific operations.
Provides a high-level API for executing standard Redis commands.
A bridge for executing queries and builders against an H2 database.
A MariaDB-aware query bridge that handles statement execution and
builder initialization.
A utility class to facilitate the creation of MySQL table builders and queries.
A PostgreSQL-aware query dispatcher.
A bridge class used to spawn table builders and queries.
A gradient that radiates outward from the origin (0,0) on the XZ plane.
A meta-feature that performs a boolean roll to decide between two distinct sub-features.
Configuration record for the random boolean feature.
A loot condition that evaluates to true based on a random probability check.
A loot condition that evaluates to true based on a probability that increases with the Looting enchantment level.
A meta-feature that evaluates a list of potential sub-features sequentially,
placing the first one that passes its individual probability check.
Configuration record for the random feature.
A record defining a PlacedFeature paired with an execution probability.
A placement modifier that slightly shifts the incoming position randomly
along all three axes based on the defined spread values.
A foliage placer that scatters individual leaf blocks randomly within a bounding area.
A placement modifier that acts as a per-chunk probability gate.
A utility class for loading, parsing, and registering Minecraft recipes from external files.
A generic registry system for managing library objects and their associated unique identifiers.
Custom event triggered when a
DeferredRegistry is applied to a Registry.A collection of standard
ParticleRenderer implementations.A specialized renderer for
Particle.DUST.A high-performance renderer that uses
ItemDisplay entities.A standard renderer that uses Bukkit's
Particle API.Handles creation, namespacing, and compilation of a resource pack.
Event triggered when a resource pack is generated by AbyssalLib.
A functional interface used to convert a row from a JDBC
ResultSet into a POJO or other data structure.Defines the registration metadata and serialization logic for a specific
AdvancementReward.The base class for all complex root generation algorithms.
Represents the registered type identifier for a specific root placer implementation.
A block state provider wrapper that intercepts the provided block state and rigidly
forces its orientation properties (Axis, Facing, or 16-point Rotation).
Represents a serialized snapshot of an entity, including its type and associated data.
A GUI layer that facilitates a scrollable view of generic data objects.
A dialog implementation specifically for displaying server link buttons.
Utility class for managing server-side component translations and MiniMessage parsing.
A loot function that modifies the stack size of a generated item to a random value within a specified range.
A loot function that sets the damage (durability loss) of a generated item based on a percentage range.
A loot function that overrides the lore (description) of a generated item.
A loot function that overrides the custom display name of a generated item.
A fundamental world generation feature that places a single block state dynamically.
Configuration record for the simple block feature.
A block state provider that always returns a single, unchanging block state.
A meta-feature that randomly selects exactly one sub-feature from a provided
list, giving each option an equal probability of selection.
Configuration record for the simple random feature.
A record defining a specific location within a GuiView.
A utility class for calculating inventory slot positions.
Represents a single physical `.ogg` audio variant linked to a broader
SoundEvent.Represents a logical sound event within Minecraft (e.g., "entity.zombie.ambient").
Acts as the centralized registry for custom sound events within a specific namespace.
A highly configurable root placer that replaces subterranean dirt compositions with designated root
structures radially outward from the base trunk origin without actively displacing the trunk vertically.
A world generation feature responsible for creating isolated liquid source blocks (springs).
Configuration record for the spring feature.
A GUI element that cycles through a list of predefined states when clicked.
Represents a single state in the cycle.
A standard trunk placer that generates a straight vertical column of blocks.
An implementation of
DynamicOps that serializes data into a custom string-based format.A procedural color provider that generates stripes alternating along a specific direction vector.
Represents a fully captured, transformable, and replayable structure definition.
A structural marker holding a serialized entity and its exact relative spatial location.
A utility class for managing and manipulating 2D structural grids of generic elements.
Fluent builder for manual cell assignment.
Defines the primary axis for iteration and rendering logic.
Fluent builder for mapping characters in a string pattern to objects.
A world generation feature that delegates generation logic to a pre-defined,
saved JSON structure file within the AbyssalLib structure registry.
Configuration record for the structure feature.
Manages the loading, saving, and registration of serialized structure files.
The base class for all structure processors.
A registry-friendly type definition for a
StructureProcessor.Marks a method as an event listener for the custom EventBus system.
A placement modifier that filters positions based on their vertical proximity
to a selected world heightmap (surface).
A gradient that sweeps around the origin like a radar or clock hand on the XZ plane.
H2-specific implementation for building table schemas.
A MariaDB-specific table schema builder.
A MySQL-specific implementation of
AbstractTableBuilder.A PostgreSQL-specific implementation of
AbstractTableBuilder.A SQLite-specific implementation of
AbstractTableBuilder.H2-specific query handler for single table operations.
A MariaDB-specific query handler for individual table operations.
A MySQL-specific implementation of
AbstractTableQuery.A PostgreSQL-specific implementation of
AbstractTableQuery.A SQLite-specific implementation of
AbstractTableQuery.An abstract representation of a data tag, which functions as a named collection of values.
A utility class responsible for loading, parsing, and registering data tags from external files.
Represents a registry type for a
Tag, defining its serialization codec
and the factory method used to create new tag instances.Utility class for scheduling Bukkit tasks.
Utility for generating invisible font-based glyph offsets to fine-tune horizontal text alignment.
Utility methods for text handling, including:
JSON serialization/deserialization with
Gson
MiniMessage parsing with MiniMessage
String/array conversions
A composite
Transformer that sequences multiple transformations over a temporal axis.Fluent builder for the
Timeline class.A utility for sending transient "Toast" notifications to players.
A fluent builder for creating
Toast notifications.A GUI element that toggles between two states (on and off) when clicked.
Functional interface for modifying particle coordinates during the animation pipeline.
The base class for all tree decoration algorithms.
Represents the registered type identifier for a specific tree decorator implementation.
Procedural feature managing the algorithmic construction of complex, modular trees.
Structure detailing the placement algorithms utilized by the tree feature.
The base class for all tree trunk generation algorithms.
Represents the registered type identifier for a specific trunk placer implementation.
A specialized tree decorator responsible for seamlessly wrapping organic vine structures
directly onto the exposed horizontal faces of the generated trunk blocks.
A monadic container type that represents a computation that may either result in a
successful value or a failure containing an exception.
A functional interface for a function that maps an input to an output and may throw an exception.
A functional interface for a runnable task that may throw a checked or unchecked exception.
A functional interface for a supplier that may throw a checked or unchecked exception.
A highly dynamic trunk placer algorithm charting a primary vertical stem that generates numerous distinct upwards-reaching structural branches.
A context object representing the details of an item interaction.
A marker interface for
DataComponents that have a direct counterpart in vanilla Minecraft.A sophisticated world generation feature that alters the terrain surface and places
vegetation on top of the newly altered ground.
Configuration record for the vegetation patch feature.
A headless block implementation designed for firing block interaction
events or applying logic without directly instantiating a full world state.
A procedural color provider that generates a Voronoi (cellular) diagram on the XZ plane.
A placement modifier that filters positions based on the depth of the water column above them.
A specialized patch feature for scattering vegetation strictly inside water columns.
Configuration record for the waterlogged vegetation feature.
A color provider that applies a sinusoidal wave modulation to a base color provider.
A block state provider that selects a block state from a pool based on relative weights.
Represents a single weighted option in the provider pool.
Represents wood types for resource pack item definitions.
Provides a unified abstraction layer for interacting with the world during
generation and population phases.
An implementation of
DynamicOps using SnakeYAML.