inline fun <E : Event, V> EventListener.computedOn(initialValue: V, priority: Short = 0, crossinline accumulator: (event: E, prev: V) -> V): ReadWriteProperty<EventListener, V>

Returns computed ReadWriteProperty based on the accumulator of specific event.

createEventHook

open override fun <T : Event> EventListener.createEventHook(eventClass: Class<T>, wrappedContext: CoroutineContext, priority: Short, handler: SuspendableEventHandler<T>): EventHook<T>

curve

inline fun curve(name: String, block: CurveValue.Builder.() -> Unit): CurveValue

fun curve(name: String, default: MutableList<Vector2f>, xAxis: CurveValue.Axis, yAxis: CurveValue.Axis, tension: Float = CurveValue.DEFAULT_TENSION): CurveValue

debugGeometry

inline fun DebuggedOwner.debugGeometry(name: String, lazyGeometry: () -> ModuleDebug.DebuggedGeometry?)

debugParameter

inline fun DebuggedOwner.debugParameter(name: String, lazyValue: () -> Any?)

deserializeFrom

open fun deserializeFrom(gson: Gson, element: JsonElement)

Deserialize value from JSON

disable

open fun disable()

doNotIncludeAlways

fun doNotIncludeAlways(): Value<MutableCollection<Value<*>>>

doNotIncludeWhen

fun doNotIncludeWhen(condition: () -> Boolean): Value<MutableCollection<Value<*>>>

drop

fun <T : ValueGroup> drop(valueGroup: T): T

easing

fun easing(name: String, default: Easing): ChoiceListValue<Easing>

enable

open fun enable()

entityTypes

fun <C : SequencedSet<EntityType<*>>> entityTypes(name: String, default: C): RegistryListValue<C, EntityType<*>>

enumChoice

inline fun <T : Enum<T>, Tagged> enumChoice(name: String, default: T): ChoiceListValue<T>

fun <T : Tagged> enumChoice(name: String, default: T, choices: Set<T>): ChoiceListValue<T>

ExpiringList

@JvmStatic

fun <E> EventListener.ExpiringList(): ExpiringList<E>

file

fun file(name: String, default: File? = null, dialogMode: FileDialogMode = FileDialogMode.OPEN_FILE, supportedExtensions: Set<String>? = null): FileValue

float

fun float(name: String, default: Float, range: ClosedFloatingPointRange<Float>, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<Float>

floatRange

fun floatRange(name: String, default: ClosedFloatingPointRange<Float>, range: ClosedFloatingPointRange<Float>, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<ClosedFloatingPointRange<Float>>

get

fun get(): MutableCollection<Value<*>>

getTagValue

@JvmName(name = "getTagValue")

fun getTagValue(): Any

getValue

@JvmName(name = "getValue")

fun getValue(): Any

operator fun getValue(u: Any?, property: KProperty<*>): MutableCollection<Value<*>>

Support for delegated properties example: var autoaim by boolean(name = "autoaim", default = true) if(!autoaim) autoaim = true

handler

inline fun <T : Event> EventListener.handler(priority: Short = 0, handler: Consumer<T>): EventHook<T>

fun <T : Event> EventListener.handler(eventClass: Class<T>, priority: Short = 0, handler: Consumer<T>): EventHook<T>

immutable

fun immutable(): Value<MutableCollection<Value<*>>>

independentDescription

fun independentDescription(): Value<MutableCollection<Value<*>>>

int

fun int(name: String, default: Int, range: IntRange, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<Int>

intRange

fun intRange(name: String, default: IntRange, range: IntRange, suffix: String = "", aliases: List<String> = emptyList()): RangedValue<IntRange>

item

fun item(name: String, default: Item): Value<Item>

items

fun <C : SequencedSet<Item>> items(name: String, default: C): RegistryListValue<C, Item>

json

fun json(valueObject: JsonObject)

Assigns the value of the settings to the component

key

fun key(name: String, default: InputConstants.Key = InputConstants.UNKNOWN): Value<InputConstants.Key>

fun key(name: String, default: Int): Value<InputConstants.Key>

mobEffects

fun <C : SequencedSet<MobEffect>> mobEffects(name: String, default: C): RegistryListValue<C, MobEffect>

multiEnumChoice

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, vararg default: T, canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: Iterable<T>, canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: EnumSet<T> = enumSetOf(), choices: EnumSet<T> = enumSetAllOf(), canBeNone: Boolean = true): MultiChoiceListValue<T?>

inline fun <T : Enum<T>, Tagged> multiEnumChoice(name: String, default: SequencedSet<T>, choices: EnumSet<T> = enumSetAllOf(), canBeNone: Boolean = true): MultiChoiceListValue<T?>

fun <T : Tagged> multiEnumChoice(name: String, default: MutableSet<T>, choices: Set<T>, canBeNone: Boolean, isOrderSensitive: Boolean): MultiChoiceListValue<T>

newEventHook

inline fun <E : Event> EventListener.newEventHook(priority: Short = 0, handler: Consumer<E>): EventHook<E>

notAnOption

fun notAnOption(): Value<MutableCollection<Value<*>>>

once

inline fun <T : Event> EventListener.once(priority: Short = 0, crossinline handler: (T) -> Unit): EventHook<T>

onChange

fun onChange(listener: ValueListener<MutableCollection<Value<*>>>): Value<MutableCollection<Value<*>>>

onChanged

fun onChanged(listener: ValueChangedListener<MutableCollection<Value<*>>>): Value<MutableCollection<Value<*>>>

parent

open override fun parent(): EventListener

Parent EventListener

regex

fun regex(name: String, default: Regex): Value<Regex>

regexList

fun <C : MutableCollection<Regex>> regexList(name: String, default: C): MutableListValue<C, Regex>

removeEventListenerScope

fun EventListener.removeEventListenerScope()

Remove cached scope and cancel it.

repeated

inline fun <T : Event> EventListener.repeated(times: Int = 1, priority: Short = 1, crossinline handler: (T) -> Unit): EventHook<T>

restore

open override fun restore()

Restore all values to their default values

s2cPackets

fun <C : SequencedSet<Identifier>> s2cPackets(name: String, default: C): RegistryListValue<C, Identifier>

sequenceHandler

inline fun <T : Event> EventListener.sequenceHandler(priority: Short = 0, dispatcher: CoroutineDispatcher? = null, onCancellation: Runnable? = null, crossinline eventHandler: SuspendableEventHandler<T>): EventHook<T>

Registers an event hook for events of type T and launches a sequence

set

fun set(t: MutableCollection<Value<*>>)

fun set(t: MutableCollection<Value<*>>, apply: Consumer<in MutableCollection<Value<*>>>)

setByString

open fun setByString(string: String)

setValue

@JvmName(name = "setValue")

fun setValue(t: Value): Result<Unit>

operator fun setValue(u: Any?, property: KProperty<*>, t: MutableCollection<Value<*>>)

sounds

fun <C : SequencedSet<SoundEvent>> sounds(name: String, default: C): RegistryListValue<C, SoundEvent>

suspendHandler

inline fun <T : Event> EventListener.suspendHandler(context: CoroutineContext = EmptyCoroutineContext, priority: Short = 0, behavior: SuspendHandlerBehavior = SuspendHandlerBehavior.Parallel.Default, noinline handler: SuspendableEventHandler<T>): EventHook<T>

Start a Job on event.

text

fun text(name: String, default: String): Value<String>

textList

fun <C : MutableCollection<String>> textList(name: String, default: C): MutableListValue<C, String>

tickHandler

inline fun EventListener.tickHandler(dispatcher: CoroutineDispatcher? = null, onCancellation: Runnable? = null, crossinline eventHandler: suspend CoroutineScope.() -> Unit): EventHook<GameTickEvent>

Registers a repeatable sequence which repeats the execution of code on GameTickEvent.

toString

open override fun toString(): String

translate

open suspend fun translate(sourceLanguage: TranslateLanguage = TranslateLanguage.Auto, targetLanguage: TranslateLanguage = TranslateLanguage.of(CommandAutoTranslate.languageCode), text: String): TranslationResult

Translates the provided text from a source language to a target language. The source language is auto-detected by default, and the target language is defined by the targetLanguage parameter.

translateInternal

open suspend override fun translateInternal(sourceLanguage: TranslateLanguage, targetLanguage: TranslateLanguage, text: String): TranslationResult

Reference Updated at 2025/06/11

tree

fun <T : ValueGroup> tree(valueGroup: T): T

treeAll

fun <T : ValueGroup> treeAll(vararg valueGroups: T)

type

fun type(): ValueType

unbind

fun Value<InputBind>.unbind()

Unbinds the key by setting it to UNKNOWN_KEY.

unregister

open fun unregister()

Unregisters the event handler from the manager. This decision is FINAL! After the class was unregistered we cannot restore the handlers.

until

inline fun <T : Event> EventListener.until(priority: Short = 0, crossinline handler: (T) -> Boolean): EventHook<T>

value

fun <V : Value<*>> value(value: V): V

fun <T : Any> value(name: String, defaultValue: T, valueType: ValueType = ValueType.INVALID, aliases: List<String> = emptyList()): Value<T>

vec2f

fun vec2f(name: String, default: Vector2fc): Value<Vector2fc>

vec3d

@JvmOverloads

fun vec3d(name: String, default: Vec3 = Vec3.ZERO, useLocateButton: Boolean = true, aliases: List<String> = emptyList()): Value<Vec3>

vec3i

@JvmOverloads

fun vec3i(name: String, default: Vec3i = Vec3i.ZERO, useLocateButton: Boolean = true, aliases: List<String> = emptyList()): Value<Vec3i>

waitMatches

inline suspend fun <T : Event> EventListener.waitMatches(priority: Short = 0, predicate: Predicate<T>): T

Wait an event of type T which matches given predicate.

suspend fun <T : Event> EventListener.waitMatches(eventClass: Class<T>, priority: Short, predicate: Predicate<T>): T

waitMatchesWithTimeout

inline suspend fun <T : Event> EventListener.waitMatchesWithTimeout(timeout: Duration, priority: Short = 0, predicate: Predicate<T>): T?

Wait an event of type T which matches given predicate. If the timeout is exceeded, return null.

walkInit

open fun walkInit()

walkKeyPath

fun walkKeyPath(previousBaseKey: String? = null)

Walks the path of the ValueGroup and its children

wrapContinuationInterceptor

fun EventListener.wrapContinuationInterceptor(original: ContinuationInterceptor? = null): ContinuationInterceptor

Wrap the original interceptor and make it auto-detect the listener's running state at suspension to determine whether to resume the continuation.