declare module "net.neoforged.neoforge.event.PlayLevelSoundEvent$AtEntity" {
import {$PlayLevelSoundEvent, $PlayLevelSoundEvent$$Type} from "net.neoforged.neoforge.event.PlayLevelSoundEvent"
import {$SoundSource, $SoundSource$$Type} from "net.minecraft.sounds.SoundSource"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $PlayLevelSoundEvent$AtEntity extends $PlayLevelSoundEvent {

constructor(arg0: $Entity$$Type, arg1: $Holder$$Type<($SoundEvent)>, arg2: $SoundSource$$Type, arg3: float, arg4: float)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayLevelSoundEvent$AtEntity$$Type = ($PlayLevelSoundEvent$AtEntity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayLevelSoundEvent$AtEntity_ = $PlayLevelSoundEvent$AtEntity$$Type;
}}
declare module "net.neoforged.neoforge.event.brewing.PotionBrewEvent$Pre" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PotionBrewEvent, $PotionBrewEvent$$Type} from "net.neoforged.neoforge.event.brewing.PotionBrewEvent"
import {$NonNullList, $NonNullList$$Type} from "net.minecraft.core.NonNullList"

export class $PotionBrewEvent$Pre extends $PotionBrewEvent implements $ICancellableEvent {

constructor(arg0: $NonNullList$$Type<($ItemStack$$Type)>)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PotionBrewEvent$Pre$$Type = ($PotionBrewEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PotionBrewEvent$Pre_ = $PotionBrewEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.ModifyDefaultComponentsEvent" {
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$DataComponentPatch$Builder, $DataComponentPatch$Builder$$Type} from "net.minecraft.core.component.DataComponentPatch$Builder"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $ModifyDefaultComponentsEvent extends $Event implements $IModBusEvent {

constructor()

public "getAllItems"(): $Stream<($Item)>
public "modifyMatching"(arg0: $Predicate$$Type<($Item)>, arg1: $Consumer$$Type<($DataComponentPatch$Builder)>): void
public "modify"(arg0: $ItemLike$$Type, arg1: $Consumer$$Type<($DataComponentPatch$Builder)>): void
get "allItems"(): $Stream<($Item)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifyDefaultComponentsEvent$$Type = ($ModifyDefaultComponentsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifyDefaultComponentsEvent_ = $ModifyDefaultComponentsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.village.WandererTradesEvent" {
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$VillagerTrades$ItemListing, $VillagerTrades$ItemListing$$Type} from "net.minecraft.world.entity.npc.VillagerTrades$ItemListing"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $WandererTradesEvent extends $Event {

/**
 * 
 * @deprecated
 */
constructor(arg0: $List$$Type<($VillagerTrades$ItemListing$$Type)>, arg1: $List$$Type<($VillagerTrades$ItemListing$$Type)>)
constructor(arg0: $List$$Type<($VillagerTrades$ItemListing$$Type)>, arg1: $List$$Type<($VillagerTrades$ItemListing$$Type)>, arg2: $RegistryAccess$$Type)

public "getRegistryAccess"(): $RegistryAccess
public "getGenericTrades"(): $List<($VillagerTrades$ItemListing)>
public "getRareTrades"(): $List<($VillagerTrades$ItemListing)>
get "registryAccess"(): $RegistryAccess
get "genericTrades"(): $List<($VillagerTrades$ItemListing)>
get "rareTrades"(): $List<($VillagerTrades$ItemListing)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $WandererTradesEvent$$Type = ($WandererTradesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $WandererTradesEvent_ = $WandererTradesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderPlayerEvent$Post" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$PlayerRenderer, $PlayerRenderer$$Type} from "net.minecraft.client.renderer.entity.player.PlayerRenderer"
import {$RenderPlayerEvent, $RenderPlayerEvent$$Type} from "net.neoforged.neoforge.client.event.RenderPlayerEvent"

export class $RenderPlayerEvent$Post extends $RenderPlayerEvent {

constructor(arg0: $Player$$Type, arg1: $PlayerRenderer$$Type, arg2: float, arg3: $PoseStack$$Type, arg4: $MultiBufferSource$$Type, arg5: integer)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderPlayerEvent$Post$$Type = ($RenderPlayerEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderPlayerEvent$Post_ = $RenderPlayerEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IHolderLookupProviderExtension" {
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Holder$Reference, $Holder$Reference$$Type} from "net.minecraft.core.Holder$Reference"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $IHolderLookupProviderExtension {

 "holder"<T>(arg0: $ResourceKey$$Type<(T)>): $Optional<($Holder$Reference<(T)>)>
 "holderOrThrow"<T>(arg0: $ResourceKey$$Type<(T)>): $Holder<(T)>
}

export namespace $IHolderLookupProviderExtension {
const probejs$$marker: never
}
export class $IHolderLookupProviderExtension$$Static implements $IHolderLookupProviderExtension {


 "holder"<T>(arg0: $ResourceKey$$Type<(T)>): $Optional<($Holder$Reference<(T)>)>
 "holderOrThrow"<T>(arg0: $ResourceKey$$Type<(T)>): $Holder<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IHolderLookupProviderExtension$$Type = ($IHolderLookupProviderExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IHolderLookupProviderExtension_ = $IHolderLookupProviderExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderFrameEvent$Post" {
import {$RenderFrameEvent, $RenderFrameEvent$$Type} from "net.neoforged.neoforge.client.event.RenderFrameEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderFrameEvent$Post extends $RenderFrameEvent {

constructor(arg0: $DeltaTracker$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderFrameEvent$Post$$Type = ($RenderFrameEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderFrameEvent$Post_ = $RenderFrameEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.common.world.chunk.TicketController" {
import {$LoadingValidationCallback, $LoadingValidationCallback$$Type} from "net.neoforged.neoforge.common.world.chunk.LoadingValidationCallback"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $TicketController extends $Record {

constructor(id: $ResourceLocation$$Type, callback: $LoadingValidationCallback$$Type)
constructor(arg0: $ResourceLocation$$Type)

public "callback"(): $LoadingValidationCallback
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "id"(): $ResourceLocation
public "forceChunk"(arg0: $ServerLevel$$Type, arg1: $BlockPos$$Type, arg2: integer, arg3: integer, arg4: boolean, arg5: boolean): boolean
public "forceChunk"(arg0: $ServerLevel$$Type, arg1: $UUID$$Type, arg2: integer, arg3: integer, arg4: boolean, arg5: boolean): boolean
public "forceChunk"(arg0: $ServerLevel$$Type, arg1: $Entity$$Type, arg2: integer, arg3: integer, arg4: boolean, arg5: boolean): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TicketController$$Type = ({"id"?: $ResourceLocation$$Type, "callback"?: $LoadingValidationCallback$$Type}) | ([id?: $ResourceLocation$$Type, callback?: $LoadingValidationCallback$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TicketController_ = $TicketController$$Type;
}}
declare module "net.neoforged.neoforge.server.command.EnumArgument$Info$Template" {
import {$ArgumentTypeInfo$Template, $ArgumentTypeInfo$Template$$Type} from "net.minecraft.commands.synchronization.ArgumentTypeInfo$Template"
import {$CommandBuildContext, $CommandBuildContext$$Type} from "net.minecraft.commands.CommandBuildContext"
import {$EnumArgument, $EnumArgument$$Type} from "net.neoforged.neoforge.server.command.EnumArgument"
import {$ArgumentTypeInfo, $ArgumentTypeInfo$$Type} from "net.minecraft.commands.synchronization.ArgumentTypeInfo"

export class $EnumArgument$Info$Template implements $ArgumentTypeInfo$Template<($EnumArgument<(T)>)> {


public "type"(): $ArgumentTypeInfo<($EnumArgument<(T)>), (any)>
public "instantiate"(arg0: $CommandBuildContext$$Type): $EnumArgument<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnumArgument$Info$Template$$Type = ($EnumArgument$Info$Template);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnumArgument$Info$Template_ = $EnumArgument$Info$Template$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent$Start" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityUseItemEvent, $LivingEntityUseItemEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent"

export class $LivingEntityUseItemEvent$Start extends $LivingEntityUseItemEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEntityUseItemEvent$Start$$Type = ($LivingEntityUseItemEvent$Start);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEntityUseItemEvent$Start_ = $LivingEntityUseItemEvent$Start$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent$LoggingIn" {
import {$MultiPlayerGameMode, $MultiPlayerGameMode$$Type} from "net.minecraft.client.multiplayer.MultiPlayerGameMode"
import {$LocalPlayer, $LocalPlayer$$Type} from "net.minecraft.client.player.LocalPlayer"
import {$ClientPlayerNetworkEvent, $ClientPlayerNetworkEvent$$Type} from "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export class $ClientPlayerNetworkEvent$LoggingIn extends $ClientPlayerNetworkEvent {

constructor(arg0: $MultiPlayerGameMode$$Type, arg1: $LocalPlayer$$Type, arg2: $Connection$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPlayerNetworkEvent$LoggingIn$$Type = ($ClientPlayerNetworkEvent$LoggingIn);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPlayerNetworkEvent$LoggingIn_ = $ClientPlayerNetworkEvent$LoggingIn$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ScreenEvent extends $Event {


public "getScreen"(): $Screen
get "screen"(): $Screen
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$$Type = ($ScreenEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent_ = $ScreenEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingSwapItemsEvent$Hands" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingSwapItemsEvent, $LivingSwapItemsEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingSwapItemsEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingSwapItemsEvent$Hands extends $LivingSwapItemsEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type)

public "getItemSwappedToOffHand"(): $ItemStack
public "getItemSwappedToMainHand"(): $ItemStack
public "setItemSwappedToOffHand"(arg0: $ItemStack$$Type): void
public "setItemSwappedToMainHand"(arg0: $ItemStack$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "itemSwappedToOffHand"(): $ItemStack
get "itemSwappedToMainHand"(): $ItemStack
set "itemSwappedToOffHand"(value: $ItemStack$$Type)
set "itemSwappedToMainHand"(value: $ItemStack$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingSwapItemsEvent$Hands$$Type = ($LivingSwapItemsEvent$Hands);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingSwapItemsEvent$Hands_ = $LivingSwapItemsEvent$Hands$$Type;
}}
declare module "net.neoforged.neoforge.resource.ContextAwareReloadListener" {
import {$CompletableFuture, $CompletableFuture$$Type} from "java.util.concurrent.CompletableFuture"
import {$Executor, $Executor$$Type} from "java.util.concurrent.Executor"
import {$ICondition$IContext, $ICondition$IContext$$Type} from "net.neoforged.neoforge.common.conditions.ICondition$IContext"
import {$PreparableReloadListener, $PreparableReloadListener$$Type} from "net.minecraft.server.packs.resources.PreparableReloadListener"
import {$PreparableReloadListener$PreparationBarrier, $PreparableReloadListener$PreparationBarrier$$Type} from "net.minecraft.server.packs.resources.PreparableReloadListener$PreparationBarrier"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$ProfilerFiller, $ProfilerFiller$$Type} from "net.minecraft.util.profiling.ProfilerFiller"
import {$ResourceManager, $ResourceManager$$Type} from "net.minecraft.server.packs.resources.ResourceManager"

export class $ContextAwareReloadListener implements $PreparableReloadListener {

constructor()

public "injectContext"(arg0: $ICondition$IContext$$Type, arg1: $HolderLookup$Provider$$Type): void
public "getName"(): string
public "reload"(arg0: $PreparableReloadListener$PreparationBarrier$$Type, arg1: $ResourceManager$$Type, arg2: $ProfilerFiller$$Type, arg3: $ProfilerFiller$$Type, arg4: $Executor$$Type, arg5: $Executor$$Type): $CompletableFuture<(void)>
get "name"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ContextAwareReloadListener$$Type = ($ContextAwareReloadListener);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ContextAwareReloadListener_ = $ContextAwareReloadListener$$Type;
}}
declare module "net.neoforged.neoforge.client.event.EntityRenderersEvent$RegisterLayerDefinitions" {
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$ModelLayerLocation, $ModelLayerLocation$$Type} from "net.minecraft.client.model.geom.ModelLayerLocation"
import {$EntityRenderersEvent, $EntityRenderersEvent$$Type} from "net.neoforged.neoforge.client.event.EntityRenderersEvent"
import {$LayerDefinition, $LayerDefinition$$Type} from "net.minecraft.client.model.geom.builders.LayerDefinition"

export class $EntityRenderersEvent$RegisterLayerDefinitions extends $EntityRenderersEvent {

constructor()

public "registerLayerDefinition"(arg0: $ModelLayerLocation$$Type, arg1: $Supplier$$Type<($LayerDefinition$$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityRenderersEvent$RegisterLayerDefinitions$$Type = ($EntityRenderersEvent$RegisterLayerDefinitions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityRenderersEvent$RegisterLayerDefinitions_ = $EntityRenderersEvent$RegisterLayerDefinitions$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientTickEvent$Post" {
import {$ClientTickEvent, $ClientTickEvent$$Type} from "net.neoforged.neoforge.client.event.ClientTickEvent"

export class $ClientTickEvent$Post extends $ClientTickEvent {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientTickEvent$Post$$Type = ($ClientTickEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientTickEvent$Post_ = $ClientTickEvent$Post$$Type;
}}
declare module "net.neoforged.fml.config.ModConfig$Type" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $ModConfig$Type extends $Enum<($ModConfig$Type)> {
static readonly "SERVER": $ModConfig$Type
static readonly "COMMON": $ModConfig$Type
static readonly "STARTUP": $ModConfig$Type
static readonly "CLIENT": $ModConfig$Type


public static "values"(): ($ModConfig$Type)[]
public static "valueOf"(arg0: string): $ModConfig$Type
public "extension"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModConfig$Type$$Type = (("common") | ("client") | ("server") | ("startup"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModConfig$Type_ = $ModConfig$Type$$Type;
}}
declare module "net.neoforged.neoforge.event.DifficultyChangeEvent" {
import {$Difficulty, $Difficulty$$Type} from "net.minecraft.world.Difficulty"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $DifficultyChangeEvent extends $Event {

constructor(arg0: $Difficulty$$Type, arg1: $Difficulty$$Type)

public "getDifficulty"(): $Difficulty
public "getOldDifficulty"(): $Difficulty
get "difficulty"(): $Difficulty
get "oldDifficulty"(): $Difficulty
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DifficultyChangeEvent$$Type = ($DifficultyChangeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DifficultyChangeEvent_ = $DifficultyChangeEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $InputEvent extends $Event {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$$Type = ($InputEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent_ = $InputEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.DimensionTransitionScreenManager$ReceivingLevelScreenFactory" {
import {$ReceivingLevelScreen$Reason, $ReceivingLevelScreen$Reason$$Type} from "net.minecraft.client.gui.screens.ReceivingLevelScreen$Reason"
import {$BooleanSupplier, $BooleanSupplier$$Type} from "java.util.function.BooleanSupplier"
import {$ReceivingLevelScreen, $ReceivingLevelScreen$$Type} from "net.minecraft.client.gui.screens.ReceivingLevelScreen"

export interface $DimensionTransitionScreenManager$ReceivingLevelScreenFactory {

 "create"(arg0: $BooleanSupplier$$Type, arg1: $ReceivingLevelScreen$Reason$$Type): $ReceivingLevelScreen

(arg0: $BooleanSupplier, arg1: $ReceivingLevelScreen$Reason): $ReceivingLevelScreen$$Type
}

export namespace $DimensionTransitionScreenManager$ReceivingLevelScreenFactory {
const probejs$$marker: never
}
export class $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Static implements $DimensionTransitionScreenManager$ReceivingLevelScreenFactory {


 "create"(arg0: $BooleanSupplier$$Type, arg1: $ReceivingLevelScreen$Reason$$Type): $ReceivingLevelScreen
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type = ((arg0: $BooleanSupplier, arg1: $ReceivingLevelScreen$Reason) => $ReceivingLevelScreen$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DimensionTransitionScreenManager$ReceivingLevelScreenFactory_ = $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingKnockBackEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingKnockBackEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: float, arg2: double, arg3: double)

public "getStrength"(): float
public "getRatioZ"(): double
public "getRatioX"(): double
public "getOriginalStrength"(): float
public "setStrength"(arg0: float): void
public "getOriginalRatioZ"(): double
public "getOriginalRatioX"(): double
public "setRatioX"(arg0: double): void
public "setRatioZ"(arg0: double): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "strength"(): float
get "ratioZ"(): double
get "ratioX"(): double
get "originalStrength"(): float
set "strength"(value: float)
get "originalRatioZ"(): double
get "originalRatioX"(): double
set "ratioX"(value: double)
set "ratioZ"(value: double)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingKnockBackEvent$$Type = ($LivingKnockBackEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingKnockBackEvent_ = $LivingKnockBackEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.AddSectionGeometryEvent" {
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$AddSectionGeometryEvent$AdditionalSectionRenderer, $AddSectionGeometryEvent$AdditionalSectionRenderer$$Type} from "net.neoforged.neoforge.client.event.AddSectionGeometryEvent$AdditionalSectionRenderer"

export class $AddSectionGeometryEvent extends $Event {

constructor(arg0: $BlockPos$$Type, arg1: $Level$$Type)

public "getLevel"(): $Level
public "getSectionOrigin"(): $BlockPos
public "addRenderer"(arg0: $AddSectionGeometryEvent$AdditionalSectionRenderer$$Type): void
public "getAdditionalRenderers"(): $List<($AddSectionGeometryEvent$AdditionalSectionRenderer)>
get "level"(): $Level
get "sectionOrigin"(): $BlockPos
get "additionalRenderers"(): $List<($AddSectionGeometryEvent$AdditionalSectionRenderer)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddSectionGeometryEvent$$Type = ($AddSectionGeometryEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddSectionGeometryEvent_ = $AddSectionGeometryEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLevelStageEvent$RegisterStageEvent" {
import {$RenderLevelStageEvent$Stage, $RenderLevelStageEvent$Stage$$Type} from "net.neoforged.neoforge.client.event.RenderLevelStageEvent$Stage"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"

export class $RenderLevelStageEvent$RegisterStageEvent extends $Event implements $IModBusEvent {

constructor()

public "register"(arg0: $ResourceLocation$$Type, arg1: $RenderType$$Type): $RenderLevelStageEvent$Stage
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLevelStageEvent$RegisterStageEvent$$Type = ($RenderLevelStageEvent$RegisterStageEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLevelStageEvent$RegisterStageEvent_ = $RenderLevelStageEvent$RegisterStageEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderBlockScreenEffectEvent$OverlayType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $RenderBlockScreenEffectEvent$OverlayType extends $Enum<($RenderBlockScreenEffectEvent$OverlayType)> {
static readonly "FIRE": $RenderBlockScreenEffectEvent$OverlayType
static readonly "BLOCK": $RenderBlockScreenEffectEvent$OverlayType
static readonly "WATER": $RenderBlockScreenEffectEvent$OverlayType


public static "values"(): ($RenderBlockScreenEffectEvent$OverlayType)[]
public static "valueOf"(arg0: string): $RenderBlockScreenEffectEvent$OverlayType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderBlockScreenEffectEvent$OverlayType$$Type = (("fire") | ("block") | ("water"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderBlockScreenEffectEvent$OverlayType_ = $RenderBlockScreenEffectEvent$OverlayType$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterParticleProvidersEvent" {
import {$ParticleProvider, $ParticleProvider$$Type} from "net.minecraft.client.particle.ParticleProvider"
import {$ParticleProvider$Sprite, $ParticleProvider$Sprite$$Type} from "net.minecraft.client.particle.ParticleProvider$Sprite"
import {$ParticleEngine, $ParticleEngine$$Type} from "net.minecraft.client.particle.ParticleEngine"
import {$ParticleType, $ParticleType$$Type} from "net.minecraft.core.particles.ParticleType"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ParticleEngine$SpriteParticleRegistration, $ParticleEngine$SpriteParticleRegistration$$Type} from "net.minecraft.client.particle.ParticleEngine$SpriteParticleRegistration"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$ParticleOptions, $ParticleOptions$$Type} from "net.minecraft.core.particles.ParticleOptions"

export class $RegisterParticleProvidersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ParticleEngine$$Type)

public "registerSpecial"<T extends $ParticleOptions>(arg0: $ParticleType$$Type<(T)>, arg1: $ParticleProvider$$Type<(T)>): void
public "registerSprite"<T extends $ParticleOptions>(arg0: $ParticleType$$Type<(T)>, arg1: $ParticleProvider$Sprite$$Type<(T)>): void
public "registerSpriteSet"<T extends $ParticleOptions>(arg0: $ParticleType$$Type<(T)>, arg1: $ParticleEngine$SpriteParticleRegistration$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterParticleProvidersEvent$$Type = ($RegisterParticleProvidersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterParticleProvidersEvent_ = $RegisterParticleProvidersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent$CreateSpawnPosition" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$ServerLevelData, $ServerLevelData$$Type} from "net.minecraft.world.level.storage.ServerLevelData"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent$CreateSpawnPosition extends $LevelEvent implements $ICancellableEvent {

constructor(arg0: $LevelAccessor$$Type, arg1: $ServerLevelData$$Type)

public "getSettings"(): $ServerLevelData
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "settings"(): $ServerLevelData
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$CreateSpawnPosition$$Type = ($LevelEvent$CreateSpawnPosition);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent$CreateSpawnPosition_ = $LevelEvent$CreateSpawnPosition$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent extends $Event {

constructor(arg0: $LevelAccessor$$Type)

public "getLevel"(): $LevelAccessor
get "level"(): $LevelAccessor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$$Type = ($LevelEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent_ = $LevelEvent$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.BlockCapability" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$List, $List$$Type} from "java.util.List"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$BaseCapability, $BaseCapability$$Type} from "net.neoforged.neoforge.capabilities.BaseCapability"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockCapability<T, C> extends $BaseCapability<(T), (C)> {


public static "create"<T, C>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>, arg2: $Class$$Type<(C)>): $BlockCapability<(T), (C)>
public static "getAll"(): $List<($BlockCapability<(any), (any)>)>
public "getCapability"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: C): T
public static "createSided"<T>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>): $BlockCapability<(T), ($Direction)>
public static "createVoid"<T>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>): $BlockCapability<(T), (void)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockCapability$$Type<T, C> = ($BlockCapability<(T), (C)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockCapability_<T, C> = $BlockCapability$$Type<(T), (C)>;
}}
declare module "net.neoforged.neoforge.registries.holdersets.AndHolderSet$Type" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ICustomHolderSet, $ICustomHolderSet$$Type} from "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$HolderSetType, $HolderSetType$$Type} from "net.neoforged.neoforge.registries.holdersets.HolderSetType"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $AndHolderSet$Type implements $HolderSetType {

constructor()

public "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
public "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AndHolderSet$Type$$Type = ($AndHolderSet$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AndHolderSet$Type_ = $AndHolderSet$Type$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModInfo$DependencyType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $IModInfo$DependencyType extends $Enum<($IModInfo$DependencyType)> {
static readonly "OPTIONAL": $IModInfo$DependencyType
static readonly "DISCOURAGED": $IModInfo$DependencyType
static readonly "REQUIRED": $IModInfo$DependencyType
static readonly "INCOMPATIBLE": $IModInfo$DependencyType


public static "values"(): ($IModInfo$DependencyType)[]
public static "valueOf"(arg0: string): $IModInfo$DependencyType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModInfo$DependencyType$$Type = (("required") | ("optional") | ("incompatible") | ("discouraged"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModInfo$DependencyType_ = $IModInfo$DependencyType$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkEvent$Load" {
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$ChunkEvent, $ChunkEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkEvent"

export class $ChunkEvent$Load extends $ChunkEvent {

constructor(arg0: $ChunkAccess$$Type, arg1: boolean)

public "isNewChunk"(): boolean
get "newChunk"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkEvent$Load$$Type = ($ChunkEvent$Load);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkEvent$Load_ = $ChunkEvent$Load$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTravelToDimensionEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTravelToDimensionEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: $ResourceKey$$Type<($Level)>)

public "getDimension"(): $ResourceKey<($Level)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "dimension"(): $ResourceKey<($Level)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTravelToDimensionEvent$$Type = ($EntityTravelToDimensionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTravelToDimensionEvent_ = $EntityTravelToDimensionEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityMobGriefingEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityMobGriefingEvent extends $EntityEvent {

constructor(arg0: $Level$$Type, arg1: $Entity$$Type)

public "canGrief"(): boolean
public "setCanGrief"(arg0: boolean): void
public "isMobGriefingEnabled"(): boolean
get "mobGriefingEnabled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityMobGriefingEvent$$Type = ($EntityMobGriefingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityMobGriefingEvent_ = $EntityMobGriefingEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderPlayerEvent$Pre" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$PlayerRenderer, $PlayerRenderer$$Type} from "net.minecraft.client.renderer.entity.player.PlayerRenderer"
import {$RenderPlayerEvent, $RenderPlayerEvent$$Type} from "net.neoforged.neoforge.client.event.RenderPlayerEvent"

export class $RenderPlayerEvent$Pre extends $RenderPlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $PlayerRenderer$$Type, arg2: float, arg3: $PoseStack$$Type, arg4: $MultiBufferSource$$Type, arg5: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderPlayerEvent$Pre$$Type = ($RenderPlayerEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderPlayerEvent$Pre_ = $RenderPlayerEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterJsonAnimationTypesEvent" {
import {$AnimationChannel$Interpolation, $AnimationChannel$Interpolation$$Type} from "net.minecraft.client.animation.AnimationChannel$Interpolation"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ImmutableMap$Builder, $ImmutableMap$Builder$$Type} from "com.google.common.collect.ImmutableMap$Builder"
import {$AnimationTarget, $AnimationTarget$$Type} from "net.neoforged.neoforge.client.entity.animation.AnimationTarget"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterJsonAnimationTypesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ImmutableMap$Builder$$Type<($ResourceLocation$$Type), ($AnimationTarget$$Type)>, arg1: $ImmutableMap$Builder$$Type<($ResourceLocation$$Type), ($AnimationChannel$Interpolation$$Type)>)

public "registerTarget"(arg0: $ResourceLocation$$Type, arg1: $AnimationTarget$$Type): void
public "registerInterpolation"(arg0: $ResourceLocation$$Type, arg1: $AnimationChannel$Interpolation$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterJsonAnimationTypesEvent$$Type = ($RegisterJsonAnimationTypesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterJsonAnimationTypesEvent_ = $RegisterJsonAnimationTypesEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.CanPlayerSleepEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$Player$BedSleepingProblem, $Player$BedSleepingProblem$$Type} from "net.minecraft.world.entity.player.Player$BedSleepingProblem"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $CanPlayerSleepEvent extends $PlayerEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $BlockPos$$Type, arg2: $Player$BedSleepingProblem$$Type)

public "getState"(): $BlockState
public "getLevel"(): $Level
public "getProblem"(): $Player$BedSleepingProblem
public "setProblem"(arg0: $Player$BedSleepingProblem$$Type): void
public "getEntity"(): $Player
public "getVanillaProblem"(): $Player$BedSleepingProblem
public "getPos"(): $BlockPos
get "state"(): $BlockState
get "level"(): $Level
get "problem"(): $Player$BedSleepingProblem
set "problem"(value: $Player$BedSleepingProblem$$Type)
get "entity"(): $Player
get "vanillaProblem"(): $Player$BedSleepingProblem
get "pos"(): $BlockPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CanPlayerSleepEvent$$Type = ($CanPlayerSleepEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CanPlayerSleepEvent_ = $CanPlayerSleepEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.AddSectionGeometryEvent$AdditionalSectionRenderer" {
import {$AddSectionGeometryEvent$SectionRenderingContext, $AddSectionGeometryEvent$SectionRenderingContext$$Type} from "net.neoforged.neoforge.client.event.AddSectionGeometryEvent$SectionRenderingContext"

export interface $AddSectionGeometryEvent$AdditionalSectionRenderer {

 "render"(arg0: $AddSectionGeometryEvent$SectionRenderingContext$$Type): void

(arg0: $AddSectionGeometryEvent$SectionRenderingContext): void
}

export namespace $AddSectionGeometryEvent$AdditionalSectionRenderer {
const probejs$$marker: never
}
export class $AddSectionGeometryEvent$AdditionalSectionRenderer$$Static implements $AddSectionGeometryEvent$AdditionalSectionRenderer {


 "render"(arg0: $AddSectionGeometryEvent$SectionRenderingContext$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddSectionGeometryEvent$AdditionalSectionRenderer$$Type = ((arg0: $AddSectionGeometryEvent$SectionRenderingContext) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddSectionGeometryEvent$AdditionalSectionRenderer_ = $AddSectionGeometryEvent$AdditionalSectionRenderer$$Type;
}}
declare module "net.neoforged.bus.api.IEventBus" {
import {$EventPriority, $EventPriority$$Type} from "net.neoforged.bus.api.EventPriority"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export interface $IEventBus {

 "register"(arg0: any): void
 "start"(): void
 "unregister"(arg0: any): void
 "post"<T extends $Event>(arg0: T): T
 "post"<T extends $Event>(arg0: $EventPriority$$Type, arg1: T): T
 "addListener"<T extends $Event>(arg0: boolean, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: boolean, arg1: $Class$$Type<(T)>, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: boolean, arg2: $Class$$Type<(T)>, arg3: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $Class$$Type<(T)>, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: $Class$$Type<(T)>, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: boolean, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $Consumer$$Type<(T)>): void
}

export namespace $IEventBus {
const probejs$$marker: never
}
export class $IEventBus$$Static implements $IEventBus {


 "register"(arg0: any): void
 "start"(): void
 "unregister"(arg0: any): void
 "post"<T extends $Event>(arg0: T): T
 "post"<T extends $Event>(arg0: $EventPriority$$Type, arg1: T): T
 "addListener"<T extends $Event>(arg0: boolean, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: boolean, arg1: $Class$$Type<(T)>, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: boolean, arg2: $Class$$Type<(T)>, arg3: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $Class$$Type<(T)>, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: $Class$$Type<(T)>, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $EventPriority$$Type, arg1: boolean, arg2: $Consumer$$Type<(T)>): void
 "addListener"<T extends $Event>(arg0: $Consumer$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IEventBus$$Type = ($IEventBus);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IEventBus_ = $IEventBus$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityEvent$EnteringSection" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$SectionPos, $SectionPos$$Type} from "net.minecraft.core.SectionPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityEvent$EnteringSection extends $EntityEvent {

constructor(arg0: $Entity$$Type, arg1: long, arg2: long)

public "getPackedOldPos"(): long
public "didChunkChange"(): boolean
public "getPackedNewPos"(): long
public "getOldPos"(): $SectionPos
public "getNewPos"(): $SectionPos
get "packedOldPos"(): long
get "packedNewPos"(): long
get "oldPos"(): $SectionPos
get "newPos"(): $SectionPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityEvent$EnteringSection$$Type = ($EntityEvent$EnteringSection);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityEvent$EnteringSection_ = $EntityEvent$EnteringSection$$Type;
}}
declare module "net.neoforged.neoforge.common.world.chunk.RegisterTicketControllersEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$TicketController, $TicketController$$Type} from "net.neoforged.neoforge.common.world.chunk.TicketController"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterTicketControllersEvent extends $Event implements $IModBusEvent {


public "register"(arg0: $TicketController$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterTicketControllersEvent$$Type = ($RegisterTicketControllersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterTicketControllersEvent_ = $RegisterTicketControllersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDrownEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingDrownEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: boolean, arg2: float, arg3: integer)
constructor(arg0: $LivingEntity$$Type)

public "setCanceled"(arg0: boolean): void
public "isDrowning"(): boolean
public "setDrowning"(arg0: boolean): void
public "setDamageAmount"(arg0: float): void
public "setBubbleCount"(arg0: integer): void
public "getDamageAmount"(): float
public "getBubbleCount"(): integer
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "drowning"(): boolean
set "drowning"(value: boolean)
set "damageAmount"(value: float)
set "bubbleCount"(value: integer)
get "damageAmount"(): float
get "bubbleCount"(): integer
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDrownEvent$$Type = ($LivingDrownEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDrownEvent_ = $LivingDrownEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ExplosionEvent" {
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"

export class $ExplosionEvent extends $Event {

constructor(arg0: $Level$$Type, arg1: $Explosion$$Type)

public "getLevel"(): $Level
public "getExplosion"(): $Explosion
get "level"(): $Level
get "explosion"(): $Explosion
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExplosionEvent$$Type = ($ExplosionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExplosionEvent_ = $ExplosionEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.StructureSettingsBuilder" {
import {$GenerationStep$Decoration, $GenerationStep$Decoration$$Type} from "net.minecraft.world.level.levelgen.GenerationStep$Decoration"
import {$MobCategory, $MobCategory$$Type} from "net.minecraft.world.entity.MobCategory"
import {$StructureSettingsBuilder$StructureSpawnOverrideBuilder, $StructureSettingsBuilder$StructureSpawnOverrideBuilder$$Type} from "net.neoforged.neoforge.common.world.StructureSettingsBuilder$StructureSpawnOverrideBuilder"
import {$HolderSet, $HolderSet$$Type} from "net.minecraft.core.HolderSet"
import {$TerrainAdjustment, $TerrainAdjustment$$Type} from "net.minecraft.world.level.levelgen.structure.TerrainAdjustment"
import {$Biome, $Biome$$Type} from "net.minecraft.world.level.biome.Biome"
import {$Structure$StructureSettings, $Structure$StructureSettings$$Type} from "net.minecraft.world.level.levelgen.structure.Structure$StructureSettings"

export class $StructureSettingsBuilder {


public static "copyOf"(arg0: $Structure$StructureSettings$$Type): $StructureSettingsBuilder
public "build"(): $Structure$StructureSettings
public "setDecorationStep"(arg0: $GenerationStep$Decoration$$Type): void
public "getDecorationStep"(): $GenerationStep$Decoration
public "getOrAddSpawnOverrides"(arg0: $MobCategory$$Type): $StructureSettingsBuilder$StructureSpawnOverrideBuilder
public "getSpawnOverrides"(arg0: $MobCategory$$Type): $StructureSettingsBuilder$StructureSpawnOverrideBuilder
public "getBiomes"(): $HolderSet<($Biome)>
public "removeSpawnOverrides"(arg0: $MobCategory$$Type): void
public "setBiomes"(arg0: $HolderSet$$Type<($Biome)>): void
public "setTerrainAdaptation"(arg0: $TerrainAdjustment$$Type): void
public "getTerrainAdaptation"(): $TerrainAdjustment
set "decorationStep"(value: $GenerationStep$Decoration$$Type)
get "decorationStep"(): $GenerationStep$Decoration
get "biomes"(): $HolderSet<($Biome)>
set "biomes"(value: $HolderSet$$Type<($Biome)>)
set "terrainAdaptation"(value: $TerrainAdjustment$$Type)
get "terrainAdaptation"(): $TerrainAdjustment
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StructureSettingsBuilder$$Type = ($StructureSettingsBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StructureSettingsBuilder_ = $StructureSettingsBuilder$$Type;
}}
declare module "net.neoforged.neoforge.event.ItemAttributeModifierEvent" {
import {$AttributeModifier, $AttributeModifier$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$EquipmentSlotGroup, $EquipmentSlotGroup$$Type} from "net.minecraft.world.entity.EquipmentSlotGroup"
import {$ItemAttributeModifiers$Entry, $ItemAttributeModifiers$Entry$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers$Entry"
import {$List, $List$$Type} from "java.util.List"
import {$ItemAttributeModifiers, $ItemAttributeModifiers$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers"
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Attribute, $Attribute$$Type} from "net.minecraft.world.entity.ai.attributes.Attribute"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $ItemAttributeModifierEvent extends $Event {

constructor(arg0: $ItemStack$$Type, arg1: $ItemAttributeModifiers$$Type)

public "getModifiers"(): $List<($ItemAttributeModifiers$Entry)>
public "removeIf"(arg0: $Predicate$$Type<($ItemAttributeModifiers$Entry)>): boolean
public "build"(): $ItemAttributeModifiers
public "removeAllModifiersFor"(arg0: $Holder$$Type<($Attribute)>): boolean
public "getDefaultModifiers"(): $ItemAttributeModifiers
public "addModifier"(arg0: $Holder$$Type<($Attribute)>, arg1: $AttributeModifier$$Type, arg2: $EquipmentSlotGroup$$Type): boolean
public "replaceModifier"(arg0: $Holder$$Type<($Attribute)>, arg1: $AttributeModifier$$Type, arg2: $EquipmentSlotGroup$$Type): void
public "clearModifiers"(): void
public "removeModifier"(arg0: $Holder$$Type<($Attribute)>, arg1: $ResourceLocation$$Type): boolean
public "getItemStack"(): $ItemStack
get "modifiers"(): $List<($ItemAttributeModifiers$Entry)>
get "defaultModifiers"(): $ItemAttributeModifiers
get "itemStack"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemAttributeModifierEvent$$Type = ($ItemAttributeModifierEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemAttributeModifierEvent_ = $ItemAttributeModifierEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.RegisterClientExtensionsEvent" {
import {$IClientItemExtensions, $IClientItemExtensions$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientItemExtensions"
import {$IClientMobEffectExtensions, $IClientMobEffectExtensions$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientMobEffectExtensions"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$IClientFluidTypeExtensions, $IClientFluidTypeExtensions$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientFluidTypeExtensions"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$IClientBlockExtensions, $IClientBlockExtensions$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientBlockExtensions"
import {$MobEffect, $MobEffect$$Type} from "net.minecraft.world.effect.MobEffect"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $RegisterClientExtensionsEvent extends $Event implements $IModBusEvent {


public "isItemRegistered"(arg0: $Item$$Type): boolean
public "isBlockRegistered"(arg0: $Block$$Type): boolean
public "registerMobEffect"(arg0: $IClientMobEffectExtensions$$Type, ...arg1: ($Holder$$Type<($MobEffect$$Type)>)[]): void
public "registerMobEffect"(arg0: $IClientMobEffectExtensions$$Type, ...arg1: ($MobEffect$$Type)[]): void
public "registerBlock"(arg0: $IClientBlockExtensions$$Type, ...arg1: ($Holder$$Type<($Block$$Type)>)[]): void
public "registerBlock"(arg0: $IClientBlockExtensions$$Type, ...arg1: ($Block$$Type)[]): void
public "registerItem"(arg0: $IClientItemExtensions$$Type, ...arg1: ($Holder$$Type<($Item$$Type)>)[]): void
public "registerItem"(arg0: $IClientItemExtensions$$Type, ...arg1: ($Item$$Type)[]): void
public "isMobEffectRegistered"(arg0: $MobEffect$$Type): boolean
public "isFluidTypeRegistered"(arg0: $FluidType$$Type): boolean
public "registerFluidType"(arg0: $IClientFluidTypeExtensions$$Type, ...arg1: ($Holder$$Type<($FluidType$$Type)>)[]): void
public "registerFluidType"(arg0: $IClientFluidTypeExtensions$$Type, ...arg1: ($FluidType$$Type)[]): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterClientExtensionsEvent$$Type = ($RegisterClientExtensionsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterClientExtensionsEvent_ = $RegisterClientExtensionsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent$Clone" {
import {$MultiPlayerGameMode, $MultiPlayerGameMode$$Type} from "net.minecraft.client.multiplayer.MultiPlayerGameMode"
import {$LocalPlayer, $LocalPlayer$$Type} from "net.minecraft.client.player.LocalPlayer"
import {$ClientPlayerNetworkEvent, $ClientPlayerNetworkEvent$$Type} from "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export class $ClientPlayerNetworkEvent$Clone extends $ClientPlayerNetworkEvent {

constructor(arg0: $MultiPlayerGameMode$$Type, arg1: $LocalPlayer$$Type, arg2: $LocalPlayer$$Type, arg3: $Connection$$Type)

public "getOldPlayer"(): $LocalPlayer
public "getNewPlayer"(): $LocalPlayer
public "getPlayer"(): $LocalPlayer
get "oldPlayer"(): $LocalPlayer
get "newPlayer"(): $LocalPlayer
get "player"(): $LocalPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPlayerNetworkEvent$Clone$$Type = ($ClientPlayerNetworkEvent$Clone);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPlayerNetworkEvent$Clone_ = $ClientPlayerNetworkEvent$Clone$$Type;
}}
declare module "net.neoforged.neoforge.fluids.FluidStack" {
import {$Potion, $Potion$$Type} from "net.minecraft.world.item.alchemy.Potion"
import {$DataComponentMap, $DataComponentMap$$Type} from "net.minecraft.core.component.DataComponentMap"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$DynamicOps, $DynamicOps$$Type} from "com.mojang.serialization.DynamicOps"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$RelativeURL, $RelativeURL$$Type} from "dev.latvian.mods.kubejs.web.RelativeURL"
import {$DataComponentType, $DataComponentType$$Type} from "net.minecraft.core.component.DataComponentType"
import {$FluidIngredient, $FluidIngredient$$Type} from "net.neoforged.neoforge.fluids.crafting.FluidIngredient"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$HolderSet, $HolderSet$$Type} from "net.minecraft.core.HolderSet"
import {$MutableDataComponentHolderFunctions, $MutableDataComponentHolderFunctions$$Type} from "dev.latvian.mods.kubejs.component.MutableDataComponentHolderFunctions"
import {$TooltipProvider, $TooltipProvider$$Type} from "net.minecraft.world.item.component.TooltipProvider"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$Rarity, $Rarity$$Type} from "net.minecraft.world.item.Rarity"
import {$LootTable, $LootTable$$Type} from "net.minecraft.world.level.storage.loot.LootTable"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$BiFunction, $BiFunction$$Type} from "java.util.function.BiFunction"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$FluidStackKJS, $FluidStackKJS$$Type} from "dev.latvian.mods.kubejs.core.FluidStackKJS"
import {$KubeColor, $KubeColor$$Type} from "dev.latvian.mods.kubejs.color.KubeColor"
import {$Unit, $Unit$$Type} from "net.minecraft.util.Unit"
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$ComponentFunctions, $ComponentFunctions$$Type} from "dev.latvian.mods.kubejs.component.ComponentFunctions"
import {$MutableDataComponentHolder, $MutableDataComponentHolder$$Type} from "net.neoforged.neoforge.common.MutableDataComponentHolder"
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$ItemAttributeModifiers$Entry, $ItemAttributeModifiers$Entry$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers$Entry"
import {$JsonElement, $JsonElement$$Type} from "com.google.gson.JsonElement"
import {$List, $List$$Type} from "java.util.List"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$DyeColor, $DyeColor$$Type} from "net.minecraft.world.item.DyeColor"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$FluidLike, $FluidLike$$Type} from "dev.latvian.mods.kubejs.fluid.FluidLike"
import {$PotionContents, $PotionContents$$Type} from "net.minecraft.world.item.alchemy.PotionContents"
import {$UnaryOperator, $UnaryOperator$$Type} from "java.util.function.UnaryOperator"
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Map, $Map$$Type} from "java.util.Map"
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"
import {$DataComponentHolder, $DataComponentHolder$$Type} from "net.minecraft.core.component.DataComponentHolder"
import {$Item$TooltipContext, $Item$TooltipContext$$Type} from "net.minecraft.world.item.Item$TooltipContext"
import {$DataComponentPatch, $DataComponentPatch$$Type} from "net.minecraft.core.component.DataComponentPatch"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$GameProfile, $GameProfile$$Type} from "com.mojang.authlib.GameProfile"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"

export class $FluidStack implements $MutableDataComponentHolder, $FluidStackKJS {
static readonly "CODEC": $Codec<($FluidStack)>
static readonly "FLUID_NON_EMPTY_CODEC": $Codec<($Holder<($Fluid)>)>
static readonly "OPTIONAL_CODEC": $Codec<($FluidStack)>
static readonly "OPTIONAL_STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($FluidStack)>
static readonly "EMPTY": $FluidStack
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($FluidStack)>

constructor(arg0: $Holder$$Type<($Fluid)>, arg1: integer)
constructor(arg0: $Fluid$$Type, arg1: integer)
constructor(arg0: $Holder$$Type<($Fluid)>, arg1: integer, arg2: $DataComponentPatch$$Type)

public "shrink"(arg0: integer): void
public static "isSameFluid"(arg0: $FluidStack$$Type, arg1: $FluidStack$$Type): boolean
public static "fixedAmountCodec"(arg0: integer): $Codec<($FluidStack)>
/**
 * 
 * @deprecated
 */
public "containsFluid"(arg0: $FluidStack$$Type): boolean
public "copyWithAmount"(arg0: integer): $FluidStack
public "getFluidHolder"(): $Holder<($Fluid)>
/**
 * 
 * @deprecated
 */
public "isFluidEqual"(arg0: $ItemStack$$Type): boolean
/**
 * 
 * @deprecated
 */
public "isFluidEqual"(arg0: $FluidStack$$Type): boolean
public "toString"(): string
public "isEmpty"(): boolean
public static "matches"(arg0: $FluidStack$$Type, arg1: $FluidStack$$Type): boolean
public "split"(arg0: integer): $FluidStack
public "save"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): $Tag
public "save"(arg0: $HolderLookup$Provider$$Type): $Tag
public static "parse"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): $Optional<($FluidStack)>
public "copy"(): $FluidStack
public "is"(arg0: $Predicate$$Type<($Holder<($Fluid)>)>): boolean
public "is"(arg0: $FluidType$$Type): boolean
public "is"(arg0: $Holder$$Type<($Fluid)>): boolean
public "is"(arg0: $TagKey$$Type<($Fluid)>): boolean
public "is"(arg0: $HolderSet$$Type<($Fluid)>): boolean
public "is"(arg0: $Fluid$$Type): boolean
public "grow"(arg0: integer): void
/**
 * 
 * @deprecated
 */
public "getDisplayName"(): $Component
public "getComponentsPatch"(): $DataComponentPatch
public static "parseOptional"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): $FluidStack
public "isComponentsPatchEmpty"(): boolean
public "getAmount"(): integer
public "limitSize"(arg0: integer): void
public "getFluidType"(): $FluidType
public "getComponents"(): $DataComponentMap
public "saveOptional"(arg0: $HolderLookup$Provider$$Type): $Tag
public static "isSameFluidSameComponents"(arg0: $FluidStack$$Type, arg1: $FluidStack$$Type): boolean
public static "hashFluidAndComponents"(arg0: $FluidStack$$Type): integer
/**
 * 
 * @deprecated
 */
public static "areFluidStackTagsEqual"(arg0: $FluidStack$$Type, arg1: $FluidStack$$Type): boolean
/**
 * 
 * @deprecated
 */
public "isFluidStackIdentical"(arg0: $FluidStack$$Type): boolean
public static "lenientOtionalFieldOf"(arg0: string): $MapCodec<($FluidStack)>
public "copyAndClear"(): $FluidStack
public "getHoverName"(): $Component
/**
 * 
 * @deprecated
 */
public "getTranslationKey"(): string
public "setAmount"(arg0: integer): void
public "getTags"(): $Stream<($TagKey<($Fluid)>)>
public "getDescriptionId"(): string
public "getFluid"(): $Fluid
public "update"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
public "update"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
public "update"<T, U>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
public "update"<T, U>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
public "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($Supplier$$Type<($DataComponentType$$Type<(any)>)>)[]): void
public "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($DataComponentType$$Type<(any)>)[]): void
public "matches"(arg1: $FluidStack$$Type, arg2: boolean): boolean
public "matches"(arg1: $FluidIngredient$$Type, arg2: boolean): boolean
public "kjs$equalsIgnoringCount"(arg0: $FluidStack$$Type): boolean
public "getFluid"(): $Fluid
public "getAmount"(): integer
public "kjs$getWebIconURL"(arg0: $DynamicOps$$Type<($Tag$$Type)>, arg1: integer): $RelativeURL
public "specialEquals"(arg1: any, arg2: boolean): boolean
public "kjs$self"(): $FluidStack
public "getKey"(): $ResourceKey<($Fluid)>
public "isEmpty"(): boolean
public "asHolder"(): $Holder<($Fluid)>
public "getRegistry"(): $Registry<($Fluid)>
public "getIdLocation"(): $ResourceLocation
public "getRegistryId"(): $ResourceKey<($Registry<($Fluid)>)>
public "replaceThisWith"(arg1: any): any
public "getMod"(): string
public "getId"(): string
public "getCodec"(): $Codec<(any)>
public "copy"(arg0: integer): $FluidLike
public "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
public "getOrDefault"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T): T
public "has"(arg0: $DataComponentType$$Type<(any)>): boolean
public "patch"(arg1: $DataComponentPatch$$Type): $ComponentFunctions
public "set"(arg1: $DataComponentMap$$Type): $MutableDataComponentHolderFunctions
public "getComponentHolder"(): $MutableDataComponentHolder
public "getComponentMap"(): $DataComponentMap
public static "checkSpecialEquality"(arg1: any, arg2: any, arg3: boolean): boolean
public "toJson"(): $JsonElement
public "toNBT"(): $Tag
public "getTags"(): $Collection<($ResourceLocation)>
public "hasTag"(arg0: $ResourceLocation$$Type): boolean
public "get"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>): T
public "getOrDefault"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): T
public "has"(arg0: $Supplier$$Type<($DataComponentType$$Type<(any)>)>): boolean
public "addToTooltip"<T extends $TooltipProvider>(arg0: $DataComponentType$$Type<(T)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
public "addToTooltip"<T extends $TooltipProvider>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
public "set"(arg1: $DataComponentType$$Type<(any)>, arg2: any): $ComponentFunctions
public "remove"(arg0: $DataComponentType$$Type<(any)>): $ComponentFunctions
public "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
public "resetComponents"(): $ComponentFunctions
public "setTooltipHidden"(): void
public "getComponentString"(): string
public "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>, arg1: long): void
public "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>): void
public "setAttributeModifiers"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
public "setPotionContents"(arg0: $PotionContents$$Type): void
public "setCustomModelData"(arg0: integer): void
public "setGlintOverride"(arg0: boolean): void
public "getCustomName"(): $Component
public "setDyedColor"(arg0: $KubeColor$$Type): void
public "setEntityData"(arg0: $CompoundTag$$Type): void
public "setProfile"(arg0: $GameProfile$$Type): void
public "setProfile"(arg0: string, arg1: $UUID$$Type): void
public "setLockCode"(arg0: string): void
public "setPotionId"(arg0: $Holder$$Type<($Potion)>): void
public "setLore"(arg0: $List$$Type<($Component$$Type)>, arg1: $List$$Type<($Component$$Type)>): void
public "setLore"(arg0: $List$$Type<($Component$$Type)>): void
public "setBaseColor"(arg0: $DyeColor$$Type): void
public "setCustomData"(arg0: $CompoundTag$$Type): void
public "getCustomData"(): $CompoundTag
public "setRarity"(arg0: $Rarity$$Type): void
public "setCustomName"(arg0: $Component$$Type): void
public "setUnit"(arg0: $DataComponentType$$Type<($Unit$$Type)>): $ComponentFunctions
public "setAttributeModifiersWithTooltip"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
public "setAdditionalTooltipHidden"(): void
public "setBlockStateProperties"(arg0: $Map$$Type<(string), (string)>): void
public "setDyedColorWithTooltip"(arg0: $KubeColor$$Type): void
public static "wrap"(arg1: any): $ReplacementMatch
get "fluidHolder"(): $Holder<($Fluid)>
get "empty"(): boolean
get "displayName"(): $Component
get "componentsPatch"(): $DataComponentPatch
get "componentsPatchEmpty"(): boolean
get "amount"(): integer
get "fluidType"(): $FluidType
get "components"(): $DataComponentMap
get "hoverName"(): $Component
get "translationKey"(): string
set "amount"(value: integer)
get "tags"(): $Stream<($TagKey<($Fluid)>)>
get "descriptionId"(): string
get "fluid"(): $Fluid
get "fluid"(): $Fluid
get "amount"(): integer
get "key"(): $ResourceKey<($Fluid)>
get "empty"(): boolean
get "registry"(): $Registry<($Fluid)>
get "idLocation"(): $ResourceLocation
get "registryId"(): $ResourceKey<($Registry<($Fluid)>)>
get "mod"(): string
get "id"(): string
get "codec"(): $Codec<(any)>
get "componentHolder"(): $MutableDataComponentHolder
get "componentMap"(): $DataComponentMap
get "tags"(): $Collection<($ResourceLocation)>
get "componentString"(): string
set "containerLootTable"(value: $ResourceKey$$Type<($LootTable)>)
set "attributeModifiers"(value: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>)
set "potionContents"(value: $PotionContents$$Type)
set "customModelData"(value: integer)
set "glintOverride"(value: boolean)
get "customName"(): $Component
set "dyedColor"(value: $KubeColor$$Type)
set "entityData"(value: $CompoundTag$$Type)
set "profile"(value: $GameProfile$$Type)
set "lockCode"(value: string)
set "potionId"(value: $Holder$$Type<($Potion)>)
set "lore"(value: $List$$Type<($Component$$Type)>)
set "baseColor"(value: $DyeColor$$Type)
set "customData"(value: $CompoundTag$$Type)
get "customData"(): $CompoundTag
set "rarity"(value: $Rarity$$Type)
set "customName"(value: $Component$$Type)
set "unit"(value: $DataComponentType$$Type<($Unit$$Type)>)
set "attributeModifiersWithTooltip"(value: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>)
set "blockStateProperties"(value: $Map$$Type<(string), (string)>)
set "dyedColorWithTooltip"(value: $KubeColor$$Type)
}
export type FluidWithAmount = {"fluid": Special.Fluid, "amount"?: integer};
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidStack$$Type = ($Fluid$$Type) | ("-") | (FluidWithAmount);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidStack_ = $FluidStack$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$PlayerChangedDimensionEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export class $PlayerEvent$PlayerChangedDimensionEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ResourceKey$$Type<($Level)>, arg2: $ResourceKey$$Type<($Level)>)

public "getFrom"(): $ResourceKey<($Level)>
public "getTo"(): $ResourceKey<($Level)>
public "getEntity"(): $LivingEntity
get "from"(): $ResourceKey<($Level)>
get "to"(): $ResourceKey<($Level)>
get "entity"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$PlayerChangedDimensionEvent$$Type = ($PlayerEvent$PlayerChangedDimensionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$PlayerChangedDimensionEvent_ = $PlayerEvent$PlayerChangedDimensionEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerDestroyItemEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerDestroyItemEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $InteractionHand$$Type)

public "getOriginal"(): $ItemStack
public "getHand"(): $InteractionHand
public "getEntity"(): $Entity
get "original"(): $ItemStack
get "hand"(): $InteractionHand
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerDestroyItemEvent$$Type = ($PlayerDestroyItemEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerDestroyItemEvent_ = $PlayerDestroyItemEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$EntityInteractSpecific" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerInteractEvent$EntityInteractSpecific extends $PlayerInteractEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $InteractionHand$$Type, arg2: $Entity$$Type, arg3: $Vec3$$Type)

public "getTarget"(): $Entity
public "getCancellationResult"(): $InteractionResult
public "setCancellationResult"(arg0: $InteractionResult$$Type): void
public "getLocalPos"(): $Vec3
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "target"(): $Entity
get "cancellationResult"(): $InteractionResult
set "cancellationResult"(value: $InteractionResult$$Type)
get "localPos"(): $Vec3
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$EntityInteractSpecific$$Type = ($PlayerInteractEvent$EntityInteractSpecific);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$EntityInteractSpecific_ = $PlayerInteractEvent$EntityInteractSpecific$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.ArmorHurtEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$EquipmentSlot, $EquipmentSlot$$Type} from "net.minecraft.world.entity.EquipmentSlot"
import {$EnumMap, $EnumMap$$Type} from "java.util.EnumMap"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ArmorHurtEvent$ArmorEntry, $ArmorHurtEvent$ArmorEntry$$Type} from "net.neoforged.neoforge.event.entity.living.ArmorHurtEvent$ArmorEntry"

export class $ArmorHurtEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $EnumMap$$Type<($EquipmentSlot$$Type), ($ArmorHurtEvent$ArmorEntry$$Type)>, arg1: $LivingEntity$$Type)

public "setNewDamage"(arg0: $EquipmentSlot$$Type, arg1: float): void
public "getNewDamage"(arg0: $EquipmentSlot$$Type): float
public "getOriginalDamage"(arg0: $EquipmentSlot$$Type): float
public "getArmorItemStack"(arg0: $EquipmentSlot$$Type): $ItemStack
public "getArmorMap"(): $Map<($EquipmentSlot), ($ArmorHurtEvent$ArmorEntry)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "armorMap"(): $Map<($EquipmentSlot), ($ArmorHurtEvent$ArmorEntry)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ArmorHurtEvent$$Type = ($ArmorHurtEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ArmorHurtEvent_ = $ArmorHurtEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterRenderBuffersEvent" {
import {$SequencedMap, $SequencedMap$$Type} from "java.util.SequencedMap"
import {$ByteBufferBuilder, $ByteBufferBuilder$$Type} from "com.mojang.blaze3d.vertex.ByteBufferBuilder"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"

export class $RegisterRenderBuffersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $SequencedMap$$Type<($RenderType$$Type), ($ByteBufferBuilder$$Type)>)

public "registerRenderBuffer"(arg0: $RenderType$$Type): void
public "registerRenderBuffer"(arg0: $RenderType$$Type, arg1: $ByteBufferBuilder$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterRenderBuffersEvent$$Type = ($RegisterRenderBuffersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterRenderBuffersEvent_ = $RegisterRenderBuffersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.BlockEntityTypeAddBlocksEvent" {
import {$BiPredicate, $BiPredicate$$Type} from "java.util.function.BiPredicate"
import {$BlockEntityType, $BlockEntityType$$Type} from "net.minecraft.world.level.block.entity.BlockEntityType"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $BlockEntityTypeAddBlocksEvent extends $Event implements $IModBusEvent {

constructor()

public "modify"(arg0: $BiPredicate$$Type<($ResourceKey<($BlockEntityType<(any)>)>), ($BlockEntityType<(any)>)>, ...arg1: ($Block$$Type)[]): void
public "modify"(arg0: $BlockEntityType$$Type<(any)>, ...arg1: ($Block$$Type)[]): void
public "modify"(arg0: $ResourceKey$$Type<($BlockEntityType<(any)>)>, ...arg1: ($Block$$Type)[]): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEntityTypeAddBlocksEvent$$Type = ($BlockEntityTypeAddBlocksEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEntityTypeAddBlocksEvent_ = $BlockEntityTypeAddBlocksEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.PlayLevelSoundEvent$AtPosition" {
import {$PlayLevelSoundEvent, $PlayLevelSoundEvent$$Type} from "net.neoforged.neoforge.event.PlayLevelSoundEvent"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$SoundSource, $SoundSource$$Type} from "net.minecraft.sounds.SoundSource"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $PlayLevelSoundEvent$AtPosition extends $PlayLevelSoundEvent {

constructor(arg0: $Level$$Type, arg1: $Vec3$$Type, arg2: $Holder$$Type<($SoundEvent)>, arg3: $SoundSource$$Type, arg4: float, arg5: float)

public "getPosition"(): $Vec3
get "position"(): $Vec3
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayLevelSoundEvent$AtPosition$$Type = ($PlayLevelSoundEvent$AtPosition);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayLevelSoundEvent$AtPosition_ = $PlayLevelSoundEvent$AtPosition$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Added" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$MobEffectEvent, $MobEffectEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobEffectEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $MobEffectEvent$Added extends $MobEffectEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $MobEffectInstance$$Type, arg2: $MobEffectInstance$$Type, arg3: $Entity$$Type)

public "getEffectInstance"(): $MobEffectInstance
public "getEffectSource"(): $Entity
public "getOldEffectInstance"(): $MobEffectInstance
get "effectInstance"(): $MobEffectInstance
get "effectSource"(): $Entity
get "oldEffectInstance"(): $MobEffectInstance
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$Added$$Type = ($MobEffectEvent$Added);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent$Added_ = $MobEffectEvent$Added$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBoatExtension" {
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"

export interface $IBoatExtension {

 "canBoatInFluid"(arg0: $FluidState$$Type): boolean
 "canBoatInFluid"(arg0: $FluidType$$Type): boolean
}

export namespace $IBoatExtension {
const probejs$$marker: never
}
export class $IBoatExtension$$Static implements $IBoatExtension {


 "canBoatInFluid"(arg0: $FluidState$$Type): boolean
 "canBoatInFluid"(arg0: $FluidType$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBoatExtension$$Type = ($IBoatExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBoatExtension_ = $IBoatExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderFrameEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderFrameEvent extends $Event {


public "getPartialTick"(): $DeltaTracker
get "partialTick"(): $DeltaTracker
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderFrameEvent$$Type = ($RenderFrameEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderFrameEvent_ = $RenderFrameEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.SoundAction" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export class $SoundAction {


public "name"(): string
public static "get"(arg0: string): $SoundAction
public "toString"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SoundAction$$Type = ($SoundAction);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SoundAction_ = $SoundAction$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$CharacterTyped" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$CharacterTyped extends $ScreenEvent {

constructor(arg0: $Screen$$Type, arg1: character, arg2: integer)

public "getModifiers"(): integer
public "getCodePoint"(): character
get "modifiers"(): integer
get "codePoint"(): character
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$CharacterTyped$$Type = ($ScreenEvent$CharacterTyped);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$CharacterTyped_ = $ScreenEvent$CharacterTyped$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$RightClickBlock" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$BlockHitResult, $BlockHitResult$$Type} from "net.minecraft.world.phys.BlockHitResult"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"

export class $PlayerInteractEvent$RightClickBlock extends $PlayerInteractEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $InteractionHand$$Type, arg2: $BlockPos$$Type, arg3: $BlockHitResult$$Type)

public "getCancellationResult"(): $InteractionResult
public "setCanceled"(arg0: boolean): void
public "getUseItem"(): $TriState
public "getUseBlock"(): $TriState
public "setUseBlock"(arg0: $TriState$$Type): void
public "getHitVec"(): $BlockHitResult
public "setUseItem"(arg0: $TriState$$Type): void
public "setCancellationResult"(arg0: $InteractionResult$$Type): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "cancellationResult"(): $InteractionResult
set "canceled"(value: boolean)
get "useItem"(): $TriState
get "useBlock"(): $TriState
set "useBlock"(value: $TriState$$Type)
get "hitVec"(): $BlockHitResult
set "useItem"(value: $TriState$$Type)
set "cancellationResult"(value: $InteractionResult$$Type)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$RightClickBlock$$Type = ($PlayerInteractEvent$RightClickBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$RightClickBlock_ = $PlayerInteractEvent$RightClickBlock$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModLanguageLoader" {
import {$IIssueReporting, $IIssueReporting$$Type} from "net.neoforged.neoforgespi.IIssueReporting"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$ModuleLayer, $ModuleLayer$$Type} from "java.lang.ModuleLayer"
import {$IModFile, $IModFile$$Type} from "net.neoforged.neoforgespi.locating.IModFile"
import {$ModFileScanData, $ModFileScanData$$Type} from "net.neoforged.neoforgespi.language.ModFileScanData"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"
import {$ModContainer, $ModContainer$$Type} from "net.neoforged.fml.ModContainer"

export interface $IModLanguageLoader {

 "name"(): string
 "version"(): string
 "validate"(arg0: $IModFile$$Type, arg1: $Collection$$Type<($ModContainer$$Type)>, arg2: $IIssueReporting$$Type): void
 "loadMod"(arg0: $IModInfo$$Type, arg1: $ModFileScanData$$Type, arg2: $ModuleLayer$$Type): $ModContainer
}

export namespace $IModLanguageLoader {
const probejs$$marker: never
}
export class $IModLanguageLoader$$Static implements $IModLanguageLoader {


 "name"(): string
 "version"(): string
 "validate"(arg0: $IModFile$$Type, arg1: $Collection$$Type<($ModContainer$$Type)>, arg2: $IIssueReporting$$Type): void
 "loadMod"(arg0: $IModInfo$$Type, arg1: $ModFileScanData$$Type, arg2: $ModuleLayer$$Type): $ModContainer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModLanguageLoader$$Type = ($IModLanguageLoader);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModLanguageLoader_ = $IModLanguageLoader$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$PlayerRespawnEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent$PlayerRespawnEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: boolean)

public "getEntity"(): $Entity
public "isEndConquered"(): boolean
get "entity"(): $Entity
get "endConquered"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$PlayerRespawnEvent$$Type = ($PlayerEvent$PlayerRespawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$PlayerRespawnEvent_ = $PlayerEvent$PlayerRespawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenshotEvent" {
import {$File, $File$$Type} from "java.io.File"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$NativeImage, $NativeImage$$Type} from "com.mojang.blaze3d.platform.NativeImage"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export class $ScreenshotEvent extends $Event implements $ICancellableEvent {
static readonly "DEFAULT_CANCEL_REASON": $Component

constructor(arg0: $NativeImage$$Type, arg1: $File$$Type)

public "getScreenshotFile"(): $File
public "setScreenshotFile"(arg0: $File$$Type): void
public "getCancelMessage"(): $Component
public "setResultMessage"(arg0: $Component$$Type): void
public "getResultMessage"(): $Component
public "getImage"(): $NativeImage
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "screenshotFile"(): $File
set "screenshotFile"(value: $File$$Type)
get "cancelMessage"(): $Component
set "resultMessage"(value: $Component$$Type)
get "resultMessage"(): $Component
get "image"(): $NativeImage
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenshotEvent$$Type = ($ScreenshotEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenshotEvent_ = $ScreenshotEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterNamedRenderTypesEvent" {
import {$RenderTypeGroup, $RenderTypeGroup$$Type} from "net.neoforged.neoforge.client.RenderTypeGroup"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"

export class $RegisterNamedRenderTypesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceLocation$$Type), ($RenderTypeGroup$$Type)>)

public "register"(arg0: $ResourceLocation$$Type, arg1: $RenderType$$Type, arg2: $RenderType$$Type): void
public "register"(arg0: $ResourceLocation$$Type, arg1: $RenderType$$Type, arg2: $RenderType$$Type, arg3: $RenderType$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterNamedRenderTypesEvent$$Type = ($RegisterNamedRenderTypesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterNamedRenderTypesEvent_ = $RegisterNamedRenderTypesEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$LogicalSide, $LogicalSide$$Type} from "net.neoforged.fml.LogicalSide"

export class $PlayerInteractEvent extends $PlayerEvent {


public "getLevel"(): $Level
public "getSide"(): $LogicalSide
public "getItemStack"(): $ItemStack
public "getHand"(): $InteractionHand
public "getFace"(): $Direction
public "getPos"(): $BlockPos
public "getEntity"(): $Entity
get "level"(): $Level
get "side"(): $LogicalSide
get "itemStack"(): $ItemStack
get "hand"(): $InteractionHand
get "face"(): $Direction
get "pos"(): $BlockPos
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$$Type = ($PlayerInteractEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent_ = $PlayerInteractEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IDataComponentHolderExtension" {
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$TooltipProvider, $TooltipProvider$$Type} from "net.minecraft.world.item.component.TooltipProvider"
import {$DataComponentType, $DataComponentType$$Type} from "net.minecraft.core.component.DataComponentType"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$Item$TooltipContext, $Item$TooltipContext$$Type} from "net.minecraft.world.item.Item$TooltipContext"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export interface $IDataComponentHolderExtension {

 "get"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>): T
 "getOrDefault"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): T
 "has"(arg0: $Supplier$$Type<($DataComponentType$$Type<(any)>)>): boolean
 "addToTooltip"<T extends $TooltipProvider>(arg0: $DataComponentType$$Type<(T)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "addToTooltip"<T extends $TooltipProvider>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
}

export namespace $IDataComponentHolderExtension {
const probejs$$marker: never
}
export class $IDataComponentHolderExtension$$Static implements $IDataComponentHolderExtension {


 "get"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>): T
 "getOrDefault"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): T
 "has"(arg0: $Supplier$$Type<($DataComponentType$$Type<(any)>)>): boolean
 "addToTooltip"<T extends $TooltipProvider>(arg0: $DataComponentType$$Type<(T)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "addToTooltip"<T extends $TooltipProvider>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IDataComponentHolderExtension$$Type = ($IDataComponentHolderExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IDataComponentHolderExtension_ = $IDataComponentHolderExtension$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IConfigurable" {
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$List, $List$$Type} from "java.util.List"

export interface $IConfigurable {

 "getConfigElement"<T>(...arg0: (string)[]): $Optional<(T)>
 "getConfigList"(...arg0: (string)[]): $List<($IConfigurable)>
}

export namespace $IConfigurable {
const probejs$$marker: never
}
export class $IConfigurable$$Static implements $IConfigurable {


 "getConfigElement"<T>(...arg0: (string)[]): $Optional<(T)>
 "getConfigList"(...arg0: (string)[]): $List<($IConfigurable)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IConfigurable$$Type = ($IConfigurable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IConfigurable_ = $IConfigurable$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiLayerEvent$Post" {
import {$LayeredDraw$Layer, $LayeredDraw$Layer$$Type} from "net.minecraft.client.gui.LayeredDraw$Layer"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$RenderGuiLayerEvent, $RenderGuiLayerEvent$$Type} from "net.neoforged.neoforge.client.event.RenderGuiLayerEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiLayerEvent$Post extends $RenderGuiLayerEvent {

constructor(arg0: $GuiGraphics$$Type, arg1: $DeltaTracker$$Type, arg2: $ResourceLocation$$Type, arg3: $LayeredDraw$Layer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiLayerEvent$Post$$Type = ($RenderGuiLayerEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiLayerEvent$Post_ = $RenderGuiLayerEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterSpriteSourceTypesEvent" {
import {$BiMap, $BiMap$$Type} from "com.google.common.collect.BiMap"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$SpriteSource, $SpriteSource$$Type} from "net.minecraft.client.renderer.texture.atlas.SpriteSource"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$SpriteSourceType, $SpriteSourceType$$Type} from "net.minecraft.client.renderer.texture.atlas.SpriteSourceType"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterSpriteSourceTypesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $BiMap$$Type<($ResourceLocation$$Type), ($SpriteSourceType$$Type)>)

/**
 * 
 * @deprecated
 */
public "register"(arg0: $ResourceLocation$$Type, arg1: $MapCodec$$Type<($SpriteSource$$Type)>): $SpriteSourceType
public "register"(arg0: $ResourceLocation$$Type, arg1: $SpriteSourceType$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterSpriteSourceTypesEvent$$Type = ($RegisterSpriteSourceTypesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterSpriteSourceTypesEvent_ = $RegisterSpriteSourceTypesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IPoseStackExtension" {
import {$Transformation, $Transformation$$Type} from "com.mojang.math.Transformation"

export interface $IPoseStackExtension {

 "pushTransformation"(arg0: $Transformation$$Type): void
}

export namespace $IPoseStackExtension {
const probejs$$marker: never
}
export class $IPoseStackExtension$$Static implements $IPoseStackExtension {


 "pushTransformation"(arg0: $Transformation$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPoseStackExtension$$Type = ($IPoseStackExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPoseStackExtension_ = $IPoseStackExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.CanContinueSleepingEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Player$BedSleepingProblem, $Player$BedSleepingProblem$$Type} from "net.minecraft.world.entity.player.Player$BedSleepingProblem"

export class $CanContinueSleepingEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $Player$BedSleepingProblem$$Type)

public "getProblem"(): $Player$BedSleepingProblem
public "setContinueSleeping"(arg0: boolean): void
public "mayContinueSleeping"(): boolean
get "problem"(): $Player$BedSleepingProblem
set "continueSleeping"(value: boolean)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CanContinueSleepingEvent$$Type = ($CanContinueSleepingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CanContinueSleepingEvent_ = $CanContinueSleepingEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ViewportEvent$ComputeFogColor" {
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$ViewportEvent, $ViewportEvent$$Type} from "net.neoforged.neoforge.client.event.ViewportEvent"

export class $ViewportEvent$ComputeFogColor extends $ViewportEvent {

constructor(arg0: $Camera$$Type, arg1: float, arg2: float, arg3: float, arg4: float)

public "getGreen"(): float
public "getRed"(): float
public "getBlue"(): float
public "setRed"(arg0: float): void
public "setBlue"(arg0: float): void
public "setGreen"(arg0: float): void
get "green"(): float
get "red"(): float
get "blue"(): float
set "red"(value: float)
set "blue"(value: float)
set "green"(value: float)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ViewportEvent$ComputeFogColor$$Type = ($ViewportEvent$ComputeFogColor);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ViewportEvent$ComputeFogColor_ = $ViewportEvent$ComputeFogColor$$Type;
}}
declare module "net.neoforged.neoforge.event.RegisterCommandsEvent" {
import {$CommandBuildContext, $CommandBuildContext$$Type} from "net.minecraft.commands.CommandBuildContext"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$CommandDispatcher, $CommandDispatcher$$Type} from "com.mojang.brigadier.CommandDispatcher"
import {$CommandSourceStack, $CommandSourceStack$$Type} from "net.minecraft.commands.CommandSourceStack"
import {$Commands$CommandSelection, $Commands$CommandSelection$$Type} from "net.minecraft.commands.Commands$CommandSelection"

export class $RegisterCommandsEvent extends $Event {

constructor(arg0: $CommandDispatcher$$Type<($CommandSourceStack$$Type)>, arg1: $Commands$CommandSelection$$Type, arg2: $CommandBuildContext$$Type)

public "getCommandSelection"(): $Commands$CommandSelection
public "getDispatcher"(): $CommandDispatcher<($CommandSourceStack)>
public "getBuildContext"(): $CommandBuildContext
get "commandSelection"(): $Commands$CommandSelection
get "dispatcher"(): $CommandDispatcher<($CommandSourceStack)>
get "buildContext"(): $CommandBuildContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterCommandsEvent$$Type = ($RegisterCommandsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterCommandsEvent_ = $RegisterCommandsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.IClientMobEffectExtensions" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$EffectRenderingInventoryScreen, $EffectRenderingInventoryScreen$$Type} from "net.minecraft.client.gui.screens.inventory.EffectRenderingInventoryScreen"
import {$Gui, $Gui$$Type} from "net.minecraft.client.gui.Gui"
import {$MobEffect, $MobEffect$$Type} from "net.minecraft.world.effect.MobEffect"

export interface $IClientMobEffectExtensions {

 "isVisibleInGui"(arg0: $MobEffectInstance$$Type): boolean
 "renderGuiIcon"(arg0: $MobEffectInstance$$Type, arg1: $Gui$$Type, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: float, arg6: float): boolean
 "renderInventoryIcon"(arg0: $MobEffectInstance$$Type, arg1: $EffectRenderingInventoryScreen$$Type<(any)>, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: integer): boolean
 "renderInventoryText"(arg0: $MobEffectInstance$$Type, arg1: $EffectRenderingInventoryScreen$$Type<(any)>, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: integer): boolean
 "isVisibleInInventory"(arg0: $MobEffectInstance$$Type): boolean
}

export namespace $IClientMobEffectExtensions {
const DEFAULT: $IClientMobEffectExtensions
function of(arg0: $MobEffectInstance$$Type): $IClientMobEffectExtensions
function of(arg0: $MobEffect$$Type): $IClientMobEffectExtensions
const probejs$$marker: never
}
export class $IClientMobEffectExtensions$$Static implements $IClientMobEffectExtensions {
static readonly "DEFAULT": $IClientMobEffectExtensions


static "of"(arg0: $MobEffectInstance$$Type): $IClientMobEffectExtensions
static "of"(arg0: $MobEffect$$Type): $IClientMobEffectExtensions
 "isVisibleInGui"(arg0: $MobEffectInstance$$Type): boolean
 "renderGuiIcon"(arg0: $MobEffectInstance$$Type, arg1: $Gui$$Type, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: float, arg6: float): boolean
 "renderInventoryIcon"(arg0: $MobEffectInstance$$Type, arg1: $EffectRenderingInventoryScreen$$Type<(any)>, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: integer): boolean
 "renderInventoryText"(arg0: $MobEffectInstance$$Type, arg1: $EffectRenderingInventoryScreen$$Type<(any)>, arg2: $GuiGraphics$$Type, arg3: integer, arg4: integer, arg5: integer): boolean
 "isVisibleInInventory"(arg0: $MobEffectInstance$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientMobEffectExtensions$$Type = ($IClientMobEffectExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientMobEffectExtensions_ = $IClientMobEffectExtensions$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$RightClickEmpty" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerInteractEvent$RightClickEmpty extends $PlayerInteractEvent {

constructor(arg0: $Player$$Type, arg1: $InteractionHand$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$RightClickEmpty$$Type = ($PlayerInteractEvent$RightClickEmpty);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$RightClickEmpty_ = $PlayerInteractEvent$RightClickEmpty$$Type;
}}
declare module "net.neoforged.bus.api.ICancellableEvent" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ICancellableEvent {

 "setCanceled"(arg0: boolean): void
 "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}

export namespace $ICancellableEvent {
const probejs$$marker: never
}
export class $ICancellableEvent$$Static implements $ICancellableEvent {


 "setCanceled"(arg0: boolean): void
 "isCanceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICancellableEvent$$Type = ($ICancellableEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICancellableEvent_ = $ICancellableEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.PistonEvent$Pre" {
import {$PistonEvent, $PistonEvent$$Type} from "net.neoforged.neoforge.event.level.PistonEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$PistonEvent$PistonMoveType, $PistonEvent$PistonMoveType$$Type} from "net.neoforged.neoforge.event.level.PistonEvent$PistonMoveType"

export class $PistonEvent$Pre extends $PistonEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $PistonEvent$PistonMoveType$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PistonEvent$Pre$$Type = ($PistonEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PistonEvent$Pre_ = $PistonEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.level.block.CropGrowEvent$Pre$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $CropGrowEvent$Pre$Result extends $Enum<($CropGrowEvent$Pre$Result)> {
static readonly "GROW": $CropGrowEvent$Pre$Result
static readonly "DO_NOT_GROW": $CropGrowEvent$Pre$Result
static readonly "DEFAULT": $CropGrowEvent$Pre$Result


public static "values"(): ($CropGrowEvent$Pre$Result)[]
public static "valueOf"(arg0: string): $CropGrowEvent$Pre$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CropGrowEvent$Pre$Result$$Type = (("grow") | ("default") | ("do_not_grow"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CropGrowEvent$Pre$Result_ = $CropGrowEvent$Pre$Result$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.UseItemOnBlockEvent$UsePhase" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $UseItemOnBlockEvent$UsePhase extends $Enum<($UseItemOnBlockEvent$UsePhase)> {
static readonly "ITEM_BEFORE_BLOCK": $UseItemOnBlockEvent$UsePhase
static readonly "BLOCK": $UseItemOnBlockEvent$UsePhase
static readonly "ITEM_AFTER_BLOCK": $UseItemOnBlockEvent$UsePhase


public static "values"(): ($UseItemOnBlockEvent$UsePhase)[]
public static "valueOf"(arg0: string): $UseItemOnBlockEvent$UsePhase
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UseItemOnBlockEvent$UsePhase$$Type = (("item_before_block") | ("block") | ("item_after_block"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UseItemOnBlockEvent$UsePhase_ = $UseItemOnBlockEvent$UsePhase$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$StopTracking" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent$StopTracking extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Entity$$Type)

public "getTarget"(): $Entity
public "getEntity"(): $Entity
get "target"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$StopTracking$$Type = ($PlayerEvent$StopTracking);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$StopTracking_ = $PlayerEvent$StopTracking$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.FinalizeSpawnEvent" {
import {$MobSpawnType, $MobSpawnType$$Type} from "net.minecraft.world.entity.MobSpawnType"
import {$ServerLevelAccessor, $ServerLevelAccessor$$Type} from "net.minecraft.world.level.ServerLevelAccessor"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$MobSpawnEvent, $MobSpawnEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobSpawnEvent"
import {$Either, $Either$$Type} from "com.mojang.datafixers.util.Either"
import {$DifficultyInstance, $DifficultyInstance$$Type} from "net.minecraft.world.DifficultyInstance"
import {$SpawnGroupData, $SpawnGroupData$$Type} from "net.minecraft.world.entity.SpawnGroupData"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"

export class $FinalizeSpawnEvent extends $MobSpawnEvent implements $ICancellableEvent {

constructor(arg0: $Mob$$Type, arg1: $ServerLevelAccessor$$Type, arg2: double, arg3: double, arg4: double, arg5: $DifficultyInstance$$Type, arg6: $MobSpawnType$$Type, arg7: $SpawnGroupData$$Type, arg8: $Either$$Type<($BlockEntity$$Type), ($Entity$$Type)>)

public "getSpawnType"(): $MobSpawnType
public "setSpawnCancelled"(arg0: boolean): void
public "getDifficulty"(): $DifficultyInstance
public "getSpawner"(): $Either<($BlockEntity), ($Entity)>
public "setDifficulty"(arg0: $DifficultyInstance$$Type): void
public "isSpawnCancelled"(): boolean
public "getSpawnData"(): $SpawnGroupData
public "setSpawnData"(arg0: $SpawnGroupData$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "spawnType"(): $MobSpawnType
set "spawnCancelled"(value: boolean)
get "difficulty"(): $DifficultyInstance
get "spawner"(): $Either<($BlockEntity), ($Entity)>
set "difficulty"(value: $DifficultyInstance$$Type)
get "spawnCancelled"(): boolean
get "spawnData"(): $SpawnGroupData
set "spawnData"(value: $SpawnGroupData$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FinalizeSpawnEvent$$Type = ($FinalizeSpawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FinalizeSpawnEvent_ = $FinalizeSpawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ILevelReaderExtension" {
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Holder$Reference, $Holder$Reference$$Type} from "net.minecraft.core.Holder$Reference"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $ILevelReaderExtension {

 "holder"<T>(arg0: $ResourceKey$$Type<(T)>): $Optional<($Holder$Reference<(T)>)>
 "holderOrThrow"<T>(arg0: $ResourceKey$$Type<(T)>): $Holder<(T)>
 "isAreaLoaded"(arg0: $BlockPos$$Type, arg1: integer): boolean
}

export namespace $ILevelReaderExtension {
const probejs$$marker: never
}
export class $ILevelReaderExtension$$Static implements $ILevelReaderExtension {


 "holder"<T>(arg0: $ResourceKey$$Type<(T)>): $Optional<($Holder$Reference<(T)>)>
 "holderOrThrow"<T>(arg0: $ResourceKey$$Type<(T)>): $Holder<(T)>
 "isAreaLoaded"(arg0: $BlockPos$$Type, arg1: integer): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ILevelReaderExtension$$Type = ($ILevelReaderExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ILevelReaderExtension_ = $ILevelReaderExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"

export class $MobEffectEvent extends $LivingEvent {


public "getEffectInstance"(): $MobEffectInstance
get "effectInstance"(): $MobEffectInstance
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$$Type = ($MobEffectEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent_ = $MobEffectEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterKeyMappingsEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$KeyMapping, $KeyMapping$$Type} from "net.minecraft.client.KeyMapping"
import {$Options, $Options$$Type} from "net.minecraft.client.Options"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterKeyMappingsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Options$$Type)

public "register"(arg0: $KeyMapping$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterKeyMappingsEvent$$Type = ($RegisterKeyMappingsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterKeyMappingsEvent_ = $RegisterKeyMappingsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.GrindstoneEvent$OnTakeItem" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$GrindstoneEvent, $GrindstoneEvent$$Type} from "net.neoforged.neoforge.event.GrindstoneEvent"

export class $GrindstoneEvent$OnTakeItem extends $GrindstoneEvent implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: integer)

public "getXp"(): integer
public "getNewBottomItem"(): $ItemStack
public "getNewTopItem"(): $ItemStack
public "setNewBottomItem"(arg0: $ItemStack$$Type): void
public "setNewTopItem"(arg0: $ItemStack$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "xp"(): integer
get "newBottomItem"(): $ItemStack
get "newTopItem"(): $ItemStack
set "newBottomItem"(value: $ItemStack$$Type)
set "newTopItem"(value: $ItemStack$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GrindstoneEvent$OnTakeItem$$Type = ($GrindstoneEvent$OnTakeItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GrindstoneEvent$OnTakeItem_ = $GrindstoneEvent$OnTakeItem$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientChatEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ClientChatEvent extends $Event implements $ICancellableEvent {

constructor(arg0: string)

public "getMessage"(): string
public "setMessage"(arg0: string): void
public "getOriginalMessage"(): string
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "message"(): string
set "message"(value: string)
get "originalMessage"(): string
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientChatEvent$$Type = ($ClientChatEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientChatEvent_ = $ClientChatEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ItemEntityPickupEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"

export class $ItemEntityPickupEvent extends $Event {

constructor(arg0: $Player$$Type, arg1: $ItemEntity$$Type)

public "getPlayer"(): $Player
public "getItemEntity"(): $ItemEntity
get "player"(): $Player
get "itemEntity"(): $ItemEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemEntityPickupEvent$$Type = ($ItemEntityPickupEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemEntityPickupEvent_ = $ItemEntityPickupEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent$ColorResolvers" {
import {$ImmutableList$Builder, $ImmutableList$Builder$$Type} from "com.google.common.collect.ImmutableList$Builder"
import {$RegisterColorHandlersEvent, $RegisterColorHandlersEvent$$Type} from "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent"
import {$ColorResolver, $ColorResolver$$Type} from "net.minecraft.world.level.ColorResolver"

export class $RegisterColorHandlersEvent$ColorResolvers extends $RegisterColorHandlersEvent {

constructor(arg0: $ImmutableList$Builder$$Type<($ColorResolver$$Type)>)

public "register"(arg0: $ColorResolver$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterColorHandlersEvent$ColorResolvers$$Type = ($RegisterColorHandlersEvent$ColorResolvers);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterColorHandlersEvent$ColorResolvers_ = $RegisterColorHandlersEvent$ColorResolvers$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.handler.IPermissionHandler" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$PermissionNode, $PermissionNode$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionNode"
import {$PermissionDynamicContext, $PermissionDynamicContext$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContext"
import {$Set, $Set$$Type} from "java.util.Set"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export interface $IPermissionHandler {

 "getPermission"<T>(arg0: $ServerPlayer$$Type, arg1: $PermissionNode$$Type<(T)>, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T
 "getIdentifier"(): $ResourceLocation
 "getRegisteredNodes"(): $Set<($PermissionNode<(any)>)>
 "getOfflinePermission"<T>(arg0: $UUID$$Type, arg1: $PermissionNode$$Type<(T)>, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T
get "identifier"(): $ResourceLocation
get "registeredNodes"(): $Set<($PermissionNode<(any)>)>
}

export namespace $IPermissionHandler {
const probejs$$marker: never
}
export class $IPermissionHandler$$Static implements $IPermissionHandler {


 "getPermission"<T>(arg0: $ServerPlayer$$Type, arg1: $PermissionNode$$Type<(T)>, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T
 "getIdentifier"(): $ResourceLocation
 "getRegisteredNodes"(): $Set<($PermissionNode<(any)>)>
 "getOfflinePermission"<T>(arg0: $UUID$$Type, arg1: $PermissionNode$$Type<(T)>, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPermissionHandler$$Type = ($IPermissionHandler);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPermissionHandler_ = $IPermissionHandler$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ILivingEntityExtension" {
import {$BiPredicate, $BiPredicate$$Type} from "java.util.function.BiPredicate"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$PartEntity, $PartEntity$$Type} from "net.neoforged.neoforge.entity.PartEntity"
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$SoundAction, $SoundAction$$Type} from "net.neoforged.neoforge.common.SoundAction"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$IEntityExtension, $IEntityExtension$$Type} from "net.neoforged.neoforge.common.extensions.IEntityExtension"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$MobCategory, $MobCategory$$Type} from "net.minecraft.world.entity.MobCategory"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"

export interface $ILivingEntityExtension extends $IEntityExtension {

 "canDrownInFluidType"(arg0: $FluidType$$Type): boolean
 "self"(): $LivingEntity
 "canSwimInFluidType"(arg0: $FluidType$$Type): boolean
 "onDamageTaken"(arg0: $DamageContainer$$Type): void
 "jumpInFluid"(arg0: $FluidType$$Type): void
 "sinkInFluid"(arg0: $FluidType$$Type): void
 "moveInFluid"(arg0: $FluidState$$Type, arg1: $Vec3$$Type, arg2: double): boolean
 "revive"(): void
 "canTrample"(arg0: $BlockState$$Type, arg1: $BlockPos$$Type, arg2: float): boolean
 "canHydrateInFluidType"(arg0: $FluidType$$Type): boolean
 "getSoundFromFluidType"(arg0: $FluidType$$Type, arg1: $SoundAction$$Type): $SoundEvent
 "copyAttachmentsFrom"(arg0: $Entity$$Type, arg1: boolean): void
 "canBeRiddenUnderFluidType"(arg0: $FluidType$$Type, arg1: $Entity$$Type): boolean
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
/**
 * 
 * @deprecated
 */
 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): $Tag
 "shouldRiderSit"(): boolean
 "canRiderInteract"(): boolean
 "getClassification"(arg0: boolean): $MobCategory
 "getFluidTypeHeight"(arg0: $FluidType$$Type): double
 "onRemovedFromLevel"(): void
 "getEyeInFluidType"(): $FluidType
 "canFluidExtinguish"(arg0: $FluidType$$Type): boolean
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): void
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): void
 "isMultipartEntity"(): boolean
 "sendPairingData"(arg0: $ServerPlayer$$Type, arg1: $Consumer$$Type<($CustomPacketPayload)>): void
 "isPushedByFluid"(arg0: $FluidType$$Type): boolean
 "getMaxHeightFluidType"(): $FluidType
 "getFluidMotionScale"(arg0: $FluidType$$Type): double
 "getParts"(): ($PartEntity<(any)>)[]
 "onAddedToLevel"(): void
 "getPersistentData"(): $CompoundTag
 "isAddedToLevel"(): boolean
 "captureDrops"(): $Collection<($ItemEntity)>
 "captureDrops"(arg0: $Collection$$Type<($ItemEntity$$Type)>): $Collection<($ItemEntity)>
 "isInFluidType"(arg0: $FluidState$$Type): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>): boolean
 "isInFluidType"(arg0: $FluidType$$Type): boolean
 "isInFluidType"(): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>, arg1: boolean): boolean
 "canStartSwimming"(): boolean
 "isEyeInFluidType"(arg0: $FluidType$$Type): boolean
 "getPickedResult"(arg0: $HitResult$$Type): $ItemStack
 "getFluidFallDistanceModifier"(arg0: $FluidType$$Type): float
get "eyeInFluidType"(): $FluidType
get "multipartEntity"(): boolean
get "maxHeightFluidType"(): $FluidType
get "parts"(): ($PartEntity<(any)>)[]
get "persistentData"(): $CompoundTag
get "addedToLevel"(): boolean
get "inFluidType"(): boolean
}

export namespace $ILivingEntityExtension {
const probejs$$marker: never
}
export class $ILivingEntityExtension$$Static implements $ILivingEntityExtension {


 "canDrownInFluidType"(arg0: $FluidType$$Type): boolean
 "self"(): $LivingEntity
 "canSwimInFluidType"(arg0: $FluidType$$Type): boolean
 "onDamageTaken"(arg0: $DamageContainer$$Type): void
 "jumpInFluid"(arg0: $FluidType$$Type): void
 "sinkInFluid"(arg0: $FluidType$$Type): void
 "moveInFluid"(arg0: $FluidState$$Type, arg1: $Vec3$$Type, arg2: double): boolean
 "revive"(): void
 "canTrample"(arg0: $BlockState$$Type, arg1: $BlockPos$$Type, arg2: float): boolean
 "canHydrateInFluidType"(arg0: $FluidType$$Type): boolean
 "getSoundFromFluidType"(arg0: $FluidType$$Type, arg1: $SoundAction$$Type): $SoundEvent
 "copyAttachmentsFrom"(arg0: $Entity$$Type, arg1: boolean): void
 "canBeRiddenUnderFluidType"(arg0: $FluidType$$Type, arg1: $Entity$$Type): boolean
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
/**
 * 
 * @deprecated
 */
 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): $Tag
 "shouldRiderSit"(): boolean
 "canRiderInteract"(): boolean
 "getClassification"(arg0: boolean): $MobCategory
 "getFluidTypeHeight"(arg0: $FluidType$$Type): double
 "onRemovedFromLevel"(): void
 "getEyeInFluidType"(): $FluidType
 "canFluidExtinguish"(arg0: $FluidType$$Type): boolean
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): void
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): void
 "isMultipartEntity"(): boolean
 "sendPairingData"(arg0: $ServerPlayer$$Type, arg1: $Consumer$$Type<($CustomPacketPayload)>): void
 "isPushedByFluid"(arg0: $FluidType$$Type): boolean
 "getMaxHeightFluidType"(): $FluidType
 "getFluidMotionScale"(arg0: $FluidType$$Type): double
 "getParts"(): ($PartEntity<(any)>)[]
 "onAddedToLevel"(): void
 "getPersistentData"(): $CompoundTag
 "isAddedToLevel"(): boolean
 "captureDrops"(): $Collection<($ItemEntity)>
 "captureDrops"(arg0: $Collection$$Type<($ItemEntity$$Type)>): $Collection<($ItemEntity)>
 "isInFluidType"(arg0: $FluidState$$Type): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>): boolean
 "isInFluidType"(arg0: $FluidType$$Type): boolean
 "isInFluidType"(): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>, arg1: boolean): boolean
 "canStartSwimming"(): boolean
 "isEyeInFluidType"(arg0: $FluidType$$Type): boolean
 "getPickedResult"(arg0: $HitResult$$Type): $ItemStack
 "getFluidFallDistanceModifier"(arg0: $FluidType$$Type): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ILivingEntityExtension$$Type = ($ILivingEntityExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ILivingEntityExtension_ = $ILivingEntityExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$CharacterTyped$Pre" {
import {$ScreenEvent$CharacterTyped, $ScreenEvent$CharacterTyped$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$CharacterTyped"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$CharacterTyped$Pre extends $ScreenEvent$CharacterTyped implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: character, arg2: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$CharacterTyped$Pre$$Type = ($ScreenEvent$CharacterTyped$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$CharacterTyped$Pre_ = $ScreenEvent$CharacterTyped$Pre$$Type;
}}
declare module "net.neoforged.neoforge.common.crafting.SizedIngredient" {
import {$Iterable, $Iterable$$Type} from "java.lang.Iterable"
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$Ingredient, $Ingredient$$Type} from "net.minecraft.world.item.crafting.Ingredient"
import {$SizedIngredientKJS, $SizedIngredientKJS$$Type} from "dev.latvian.mods.kubejs.core.SizedIngredientKJS"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"

export class $SizedIngredient implements $SizedIngredientKJS {
static readonly "NESTED_CODEC": $Codec<($SizedIngredient)>
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($SizedIngredient)>
static readonly "FLAT_CODEC": $Codec<($SizedIngredient)>

constructor(arg0: $Ingredient$$Type, arg1: integer)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: $ItemStack$$Type): boolean
public static "of"(arg0: $ItemLike$$Type, arg1: integer): $SizedIngredient
public static "of"(arg0: $TagKey$$Type<($Item)>, arg1: integer): $SizedIngredient
public "count"(): integer
public "ingredient"(): $Ingredient
public "getItems"(): ($ItemStack)[]
public "matches"(arg1: $Ingredient$$Type, arg2: boolean): boolean
public "matches"(arg1: $ItemStack$$Type, arg2: boolean): boolean
public "kjs$asIngredient"(): $Ingredient
public "kjs$self"(): $SizedIngredient
public "replaceThisWith"(arg1: any): any
public "matches"(arg1: $ItemLike$$Type, arg2: boolean): boolean
public "matchesAny"(arg1: $Iterable$$Type<($ItemLike$$Type)>, arg2: boolean): boolean
public static "wrap"(arg1: any): $ReplacementMatch
get "items"(): ($ItemStack)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SizedIngredient$$Type = ($ItemStack$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SizedIngredient_ = $SizedIngredient$$Type;
}}
declare module "net.neoforged.neoforge.client.event.GatherSkippedAttributeTooltipsEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$EquipmentSlotGroup, $EquipmentSlotGroup$$Type} from "net.minecraft.world.entity.EquipmentSlotGroup"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$AttributeTooltipContext, $AttributeTooltipContext$$Type} from "net.neoforged.neoforge.common.util.AttributeTooltipContext"

export class $GatherSkippedAttributeTooltipsEvent extends $Event {

constructor(arg0: $ItemStack$$Type, arg1: $AttributeTooltipContext$$Type)

public "getContext"(): $AttributeTooltipContext
public "getStack"(): $ItemStack
public "setSkipAll"(arg0: boolean): void
public "isSkipped"(arg0: $EquipmentSlotGroup$$Type): boolean
public "isSkipped"(arg0: $ResourceLocation$$Type): boolean
public "skipId"(arg0: $ResourceLocation$$Type): void
public "skipGroup"(arg0: $EquipmentSlotGroup$$Type): void
public "isSkippingAll"(): boolean
get "context"(): $AttributeTooltipContext
get "stack"(): $ItemStack
set "skipAll"(value: boolean)
get "skippingAll"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GatherSkippedAttributeTooltipsEvent$$Type = ($GatherSkippedAttributeTooltipsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GatherSkippedAttributeTooltipsEvent_ = $GatherSkippedAttributeTooltipsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Applicable$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $MobEffectEvent$Applicable$Result extends $Enum<($MobEffectEvent$Applicable$Result)> {
static readonly "DO_NOT_APPLY": $MobEffectEvent$Applicable$Result
static readonly "APPLY": $MobEffectEvent$Applicable$Result
static readonly "DEFAULT": $MobEffectEvent$Applicable$Result


public static "values"(): ($MobEffectEvent$Applicable$Result)[]
public static "valueOf"(arg0: string): $MobEffectEvent$Applicable$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$Applicable$Result$$Type = (("apply") | ("default") | ("do_not_apply"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent$Applicable$Result_ = $MobEffectEvent$Applicable$Result$$Type;
}}
declare module "net.neoforged.neoforge.event.level.AlterGroundEvent" {
import {$AlterGroundEvent$StateProvider, $AlterGroundEvent$StateProvider$$Type} from "net.neoforged.neoforge.event.level.AlterGroundEvent$StateProvider"
import {$TreeDecorator$Context, $TreeDecorator$Context$$Type} from "net.minecraft.world.level.levelgen.feature.treedecorators.TreeDecorator$Context"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export class $AlterGroundEvent extends $Event {

constructor(arg0: $TreeDecorator$Context$$Type, arg1: $List$$Type<($BlockPos$$Type)>, arg2: $AlterGroundEvent$StateProvider$$Type)

public "getContext"(): $TreeDecorator$Context
public "getStateProvider"(): $AlterGroundEvent$StateProvider
public "setStateProvider"(arg0: $AlterGroundEvent$StateProvider$$Type): void
public "getPositions"(): $List<($BlockPos)>
get "context"(): $TreeDecorator$Context
get "stateProvider"(): $AlterGroundEvent$StateProvider
set "stateProvider"(value: $AlterGroundEvent$StateProvider$$Type)
get "positions"(): $List<($BlockPos)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AlterGroundEvent$$Type = ($AlterGroundEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AlterGroundEvent_ = $AlterGroundEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.IClientBlockExtensions" {
import {$ClientLevel, $ClientLevel$$Type} from "net.minecraft.client.multiplayer.ClientLevel"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$ParticleEngine, $ParticleEngine$$Type} from "net.minecraft.client.particle.ParticleEngine"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Vector3d, $Vector3d$$Type} from "org.joml.Vector3d"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IClientBlockExtensions {

 "playBreakSound"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
 "addHitEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $HitResult$$Type, arg3: $ParticleEngine$$Type): boolean
 "addDestroyEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $ParticleEngine$$Type): boolean
 "areBreakingParticlesTinted"(arg0: $BlockState$$Type, arg1: $ClientLevel$$Type, arg2: $BlockPos$$Type): boolean
 "getFogColor"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type, arg4: $Vector3d$$Type, arg5: float): $Vector3d
}

export namespace $IClientBlockExtensions {
const DEFAULT: $IClientBlockExtensions
function of(arg0: $BlockState$$Type): $IClientBlockExtensions
function of(arg0: $Block$$Type): $IClientBlockExtensions
const probejs$$marker: never
}
export class $IClientBlockExtensions$$Static implements $IClientBlockExtensions {
static readonly "DEFAULT": $IClientBlockExtensions


static "of"(arg0: $BlockState$$Type): $IClientBlockExtensions
static "of"(arg0: $Block$$Type): $IClientBlockExtensions
 "playBreakSound"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
 "addHitEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $HitResult$$Type, arg3: $ParticleEngine$$Type): boolean
 "addDestroyEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $ParticleEngine$$Type): boolean
 "areBreakingParticlesTinted"(arg0: $BlockState$$Type, arg1: $ClientLevel$$Type, arg2: $BlockPos$$Type): boolean
 "getFogColor"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type, arg4: $Vector3d$$Type, arg5: float): $Vector3d
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientBlockExtensions$$Type = ($IClientBlockExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientBlockExtensions_ = $IClientBlockExtensions$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableStructureInfo$StructureInfo" {
import {$Structure$StructureSettings, $Structure$StructureSettings$$Type} from "net.minecraft.world.level.levelgen.structure.Structure$StructureSettings"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModifiableStructureInfo$StructureInfo extends $Record {

constructor(structureSettings: $Structure$StructureSettings$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "structureSettings"(): $Structure$StructureSettings
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableStructureInfo$StructureInfo$$Type = ({"structureSettings"?: $Structure$StructureSettings$$Type}) | ([structureSettings?: $Structure$StructureSettings$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableStructureInfo$StructureInfo_ = $ModifiableStructureInfo$StructureInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkWatchEvent$Sent" {
import {$ChunkWatchEvent, $ChunkWatchEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkWatchEvent"
import {$LevelChunk, $LevelChunk$$Type} from "net.minecraft.world.level.chunk.LevelChunk"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export class $ChunkWatchEvent$Sent extends $ChunkWatchEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $LevelChunk$$Type, arg2: $ServerLevel$$Type)

public "getChunk"(): $LevelChunk
get "chunk"(): $LevelChunk
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkWatchEvent$Sent$$Type = ($ChunkWatchEvent$Sent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkWatchEvent$Sent_ = $ChunkWatchEvent$Sent$$Type;
}}
declare module "net.neoforged.neoforge.common.BooleanAttribute" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$AttributeModifier, $AttributeModifier$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier"
import {$AttributeModifier$Operation, $AttributeModifier$Operation$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier$Operation"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$Attribute, $Attribute$$Type} from "net.minecraft.world.entity.ai.attributes.Attribute"
import {$MutableComponent, $MutableComponent$$Type} from "net.minecraft.network.chat.MutableComponent"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $BooleanAttribute extends $Attribute {
static readonly "CODEC": $Codec<($Holder<($Attribute)>)>
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($Holder<($Attribute)>)>

constructor(arg0: string, arg1: boolean)

public "toValueComponent"(arg0: $AttributeModifier$Operation$$Type, arg1: double, arg2: $TooltipFlag$$Type): $MutableComponent
public "sanitizeValue"(arg0: double): double
public "toComponent"(arg0: $AttributeModifier$$Type, arg1: $TooltipFlag$$Type): $MutableComponent
public static "isNullOrAddition"(arg0: $AttributeModifier$Operation$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BooleanAttribute$$Type = ($BooleanAttribute);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BooleanAttribute_ = $BooleanAttribute$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEvent$LivingVisibilityEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $LivingEvent$LivingVisibilityEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $Entity$$Type, arg2: double)

public "getEntity"(): $Entity
public "getVisibilityModifier"(): double
public "getLookingEntity"(): $Entity
public "modifyVisibility"(arg0: double): void
get "entity"(): $Entity
get "visibilityModifier"(): double
get "lookingEntity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEvent$LivingVisibilityEvent$$Type = ($LivingEvent$LivingVisibilityEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEvent$LivingVisibilityEvent_ = $LivingEvent$LivingVisibilityEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.callback.ClearCallback" {
import {$RegistryCallback, $RegistryCallback$$Type} from "net.neoforged.neoforge.registries.callback.RegistryCallback"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"

export interface $ClearCallback<T> extends $RegistryCallback<(T)> {

 "onClear"(arg0: $Registry$$Type<(T)>, arg1: boolean): void

(arg0: $Registry<(T)>, arg1: boolean): void
}

export namespace $ClearCallback {
const probejs$$marker: never
}
export class $ClearCallback$$Static<T> implements $ClearCallback {


 "onClear"(arg0: $Registry$$Type<(T)>, arg1: boolean): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClearCallback$$Type<T> = ((arg0: $Registry<(T)>, arg1: boolean) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClearCallback_<T> = $ClearCallback$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent$Finish" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityUseItemEvent, $LivingEntityUseItemEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent"

export class $LivingEntityUseItemEvent$Finish extends $LivingEntityUseItemEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: integer, arg3: $ItemStack$$Type)

public "getResultStack"(): $ItemStack
public "setResultStack"(arg0: $ItemStack$$Type): void
get "resultStack"(): $ItemStack
set "resultStack"(value: $ItemStack$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEntityUseItemEvent$Finish$$Type = ($LivingEntityUseItemEvent$Finish);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEntityUseItemEvent$Finish_ = $LivingEntityUseItemEvent$Finish$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLivingEvent$Post" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$EntityModel, $EntityModel$$Type} from "net.minecraft.client.model.EntityModel"
import {$RenderLivingEvent, $RenderLivingEvent$$Type} from "net.neoforged.neoforge.client.event.RenderLivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityRenderer, $LivingEntityRenderer$$Type} from "net.minecraft.client.renderer.entity.LivingEntityRenderer"

export class $RenderLivingEvent$Post<T extends $LivingEntity, M extends $EntityModel<(T)>> extends $RenderLivingEvent<(T), (M)> {

constructor(arg0: $LivingEntity$$Type, arg1: $LivingEntityRenderer$$Type<(T), (M)>, arg2: float, arg3: $PoseStack$$Type, arg4: $MultiBufferSource$$Type, arg5: integer)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLivingEvent$Post$$Type<T, M> = ($RenderLivingEvent$Post<(T), (M)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLivingEvent$Post_<T, M> = $RenderLivingEvent$Post$$Type<(T), (M)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.ClientInformationUpdatedEvent" {
import {$ClientInformation, $ClientInformation$$Type} from "net.minecraft.server.level.ClientInformation"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export class $ClientInformationUpdatedEvent extends $PlayerEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $ClientInformation$$Type, arg2: $ClientInformation$$Type)

public "getOldInformation"(): $ClientInformation
public "getEntity"(): $LivingEntity
public "getUpdatedInformation"(): $ClientInformation
get "oldInformation"(): $ClientInformation
get "entity"(): $LivingEntity
get "updatedInformation"(): $ClientInformation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientInformationUpdatedEvent$$Type = ($ClientInformationUpdatedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientInformationUpdatedEvent_ = $ClientInformationUpdatedEvent$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.EntityCapability" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$List, $List$$Type} from "java.util.List"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BaseCapability, $BaseCapability$$Type} from "net.neoforged.neoforge.capabilities.BaseCapability"

export class $EntityCapability<T, C> extends $BaseCapability<(T), (C)> {


public static "create"<T, C>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>, arg2: $Class$$Type<(C)>): $EntityCapability<(T), (C)>
public static "getAll"(): $List<($EntityCapability<(any), (any)>)>
public "getCapability"(arg0: $Entity$$Type, arg1: C): T
public static "createSided"<T>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>): $EntityCapability<(T), ($Direction)>
public static "createVoid"<T>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>): $EntityCapability<(T), (void)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityCapability$$Type<T, C> = ($EntityCapability<(T), (C)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityCapability_<T, C> = $EntityCapability$$Type<(T), (C)>;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent$SpreadPlayersCommand" {
import {$EntityTeleportEvent, $EntityTeleportEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityTeleportEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTeleportEvent$SpreadPlayersCommand extends $EntityTeleportEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: double, arg2: double, arg3: double)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$SpreadPlayersCommand$$Type = ($EntityTeleportEvent$SpreadPlayersCommand);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent$SpreadPlayersCommand_ = $EntityTeleportEvent$SpreadPlayersCommand$$Type;
}}
declare module "net.neoforged.neoforge.event.LootTableLoadEvent" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$LootTable, $LootTable$$Type} from "net.minecraft.world.level.storage.loot.LootTable"

export class $LootTableLoadEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ResourceLocation$$Type, arg1: $LootTable$$Type)

public "getName"(): $ResourceLocation
public "getTable"(): $LootTable
public "setTable"(arg0: $LootTable$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "name"(): $ResourceLocation
get "table"(): $LootTable
set "table"(value: $LootTable$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LootTableLoadEvent$$Type = ($LootTableLoadEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LootTableLoadEvent_ = $LootTableLoadEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Window, $Window$$Type} from "com.mojang.blaze3d.platform.Window"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $CustomizeGuiOverlayEvent extends $Event {


public "getGuiGraphics"(): $GuiGraphics
public "getWindow"(): $Window
public "getPartialTick"(): $DeltaTracker
get "guiGraphics"(): $GuiGraphics
get "window"(): $Window
get "partialTick"(): $DeltaTracker
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CustomizeGuiOverlayEvent$$Type = ($CustomizeGuiOverlayEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CustomizeGuiOverlayEvent_ = $CustomizeGuiOverlayEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.ServerTickEvent$Pre" {
import {$BooleanSupplier, $BooleanSupplier$$Type} from "java.util.function.BooleanSupplier"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"
import {$ServerTickEvent, $ServerTickEvent$$Type} from "net.neoforged.neoforge.event.tick.ServerTickEvent"

export class $ServerTickEvent$Pre extends $ServerTickEvent {

constructor(arg0: $BooleanSupplier$$Type, arg1: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerTickEvent$Pre$$Type = ($ServerTickEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerTickEvent$Pre_ = $ServerTickEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.fluids.crafting.FluidIngredientType" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$FluidIngredient, $FluidIngredient$$Type} from "net.neoforged.neoforge.fluids.crafting.FluidIngredient"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $FluidIngredientType<T extends $FluidIngredient> extends $Record {

constructor(arg0: $MapCodec$$Type<(T)>)
constructor(codec: $MapCodec$$Type<(T)>, streamCodec: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (T)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "streamCodec"(): $StreamCodec<($RegistryFriendlyByteBuf), (T)>
public "codec"(): $MapCodec<(T)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeFluidIngredientType
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeFluidIngredientTypeTag
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidIngredientType$$Type<T> = (Special.NeoforgeFluidIngredientType) | ({"streamCodec"?: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (any)>, "codec"?: $MapCodec$$Type<(any)>}) | ([streamCodec?: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (any)>, codec?: $MapCodec$$Type<(any)>]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidIngredientType_<T> = $FluidIngredientType$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$EntityMultiPlaceEvent" {
import {$BlockEvent$EntityPlaceEvent, $BlockEvent$EntityPlaceEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent$EntityPlaceEvent"
import {$BlockSnapshot, $BlockSnapshot$$Type} from "net.neoforged.neoforge.common.util.BlockSnapshot"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$EntityMultiPlaceEvent extends $BlockEvent$EntityPlaceEvent implements $ICancellableEvent {

constructor(arg0: $List$$Type<($BlockSnapshot$$Type)>, arg1: $BlockState$$Type, arg2: $Entity$$Type)

public "getReplacedBlockSnapshots"(): $List<($BlockSnapshot)>
get "replacedBlockSnapshots"(): $List<($BlockSnapshot)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$EntityMultiPlaceEvent$$Type = ($BlockEvent$EntityMultiPlaceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$EntityMultiPlaceEvent_ = $BlockEvent$EntityMultiPlaceEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.model.geometry.IGeometryLoader" {
import {$JsonObject, $JsonObject$$Type} from "com.google.gson.JsonObject"
import {$JsonDeserializationContext, $JsonDeserializationContext$$Type} from "com.google.gson.JsonDeserializationContext"
import {$IUnbakedGeometry, $IUnbakedGeometry$$Type} from "net.neoforged.neoforge.client.model.geometry.IUnbakedGeometry"

export interface $IGeometryLoader<T extends $IUnbakedGeometry<(T)>> {

 "read"(arg0: $JsonObject$$Type, arg1: $JsonDeserializationContext$$Type): T

(arg0: $JsonObject, arg1: $JsonDeserializationContext): T
}

export namespace $IGeometryLoader {
const probejs$$marker: never
}
export class $IGeometryLoader$$Static<T extends $IUnbakedGeometry<(T)>> implements $IGeometryLoader {


 "read"(arg0: $JsonObject$$Type, arg1: $JsonDeserializationContext$$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IGeometryLoader$$Type<T> = ((arg0: $JsonObject, arg1: $JsonDeserializationContext) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IGeometryLoader_<T> = $IGeometryLoader$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.server.ServerAboutToStartEvent" {
import {$ServerLifecycleEvent, $ServerLifecycleEvent$$Type} from "net.neoforged.neoforge.event.server.ServerLifecycleEvent"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerAboutToStartEvent extends $ServerLifecycleEvent {

constructor(arg0: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerAboutToStartEvent$$Type = ($ServerAboutToStartEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerAboutToStartEvent_ = $ServerAboutToStartEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerContainerEvent$Close" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$PlayerContainerEvent, $PlayerContainerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerContainerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerContainerEvent$Close extends $PlayerContainerEvent {

constructor(arg0: $Player$$Type, arg1: $AbstractContainerMenu$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerContainerEvent$Close$$Type = ($PlayerContainerEvent$Close);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerContainerEvent$Close_ = $PlayerContainerEvent$Close$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$SpawnPlacementCheck$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $MobSpawnEvent$SpawnPlacementCheck$Result extends $Enum<($MobSpawnEvent$SpawnPlacementCheck$Result)> {
static readonly "SUCCEED": $MobSpawnEvent$SpawnPlacementCheck$Result
static readonly "DEFAULT": $MobSpawnEvent$SpawnPlacementCheck$Result
static readonly "FAIL": $MobSpawnEvent$SpawnPlacementCheck$Result


public static "values"(): ($MobSpawnEvent$SpawnPlacementCheck$Result)[]
public static "valueOf"(arg0: string): $MobSpawnEvent$SpawnPlacementCheck$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnEvent$SpawnPlacementCheck$Result$$Type = (("succeed") | ("default") | ("fail"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnEvent$SpawnPlacementCheck$Result_ = $MobSpawnEvent$SpawnPlacementCheck$Result$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ContainerScreenEvent$Render" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$ContainerScreenEvent, $ContainerScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ContainerScreenEvent"

export class $ContainerScreenEvent$Render extends $ContainerScreenEvent {


public "getGuiGraphics"(): $GuiGraphics
public "getMouseY"(): integer
public "getMouseX"(): integer
get "guiGraphics"(): $GuiGraphics
get "mouseY"(): integer
get "mouseX"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ContainerScreenEvent$Render$$Type = ($ContainerScreenEvent$Render);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ContainerScreenEvent$Render_ = $ContainerScreenEvent$Render$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IHolderExtension" {
import {$IWithData, $IWithData$$Type} from "net.neoforged.neoforge.registries.datamaps.IWithData"
import {$DataMapType, $DataMapType$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType"
import {$HolderLookup$RegistryLookup, $HolderLookup$RegistryLookup$$Type} from "net.minecraft.core.HolderLookup$RegistryLookup"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $IHolderExtension<T> extends $IWithData<(T)> {

 "getDelegate"(): $Holder<(T)>
 "getKey"(): $ResourceKey<(T)>
 "unwrapLookup"(): $HolderLookup$RegistryLookup<(T)>
 "getData"<T>(arg0: $DataMapType$$Type<(T), (T)>): T
get "delegate"(): $Holder<(T)>
get "key"(): $ResourceKey<(T)>
}

export namespace $IHolderExtension {
const probejs$$marker: never
}
export class $IHolderExtension$$Static<T> implements $IHolderExtension {


 "getDelegate"(): $Holder<(T)>
 "getKey"(): $ResourceKey<(T)>
 "unwrapLookup"(): $HolderLookup$RegistryLookup<(T)>
 "getData"<T>(arg0: $DataMapType$$Type<(T), (T)>): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IHolderExtension$$Type<T> = ($IHolderExtension<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IHolderExtension_<T> = $IHolderExtension$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.extensions.IItemPropertiesExtensions" {
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$Item$Properties, $Item$Properties$$Type} from "net.minecraft.world.item.Item$Properties"
import {$DataComponentType, $DataComponentType$$Type} from "net.minecraft.core.component.DataComponentType"

export interface $IItemPropertiesExtensions {

 "component"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): $Item$Properties
}

export namespace $IItemPropertiesExtensions {
const probejs$$marker: never
}
export class $IItemPropertiesExtensions$$Static implements $IItemPropertiesExtensions {


 "component"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): $Item$Properties
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IItemPropertiesExtensions$$Type = ($IItemPropertiesExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IItemPropertiesExtensions_ = $IItemPropertiesExtensions$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.TradeWithVillagerEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$MerchantOffer, $MerchantOffer$$Type} from "net.minecraft.world.item.trading.MerchantOffer"
import {$AbstractVillager, $AbstractVillager$$Type} from "net.minecraft.world.entity.npc.AbstractVillager"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $TradeWithVillagerEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $MerchantOffer$$Type, arg2: $AbstractVillager$$Type)

public "getMerchantOffer"(): $MerchantOffer
public "getAbstractVillager"(): $AbstractVillager
public "getEntity"(): $Entity
get "merchantOffer"(): $MerchantOffer
get "abstractVillager"(): $AbstractVillager
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TradeWithVillagerEvent$$Type = ($TradeWithVillagerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TradeWithVillagerEvent_ = $TradeWithVillagerEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.language.ModFileScanData$ClassData" {
import {$Set, $Set$$Type} from "java.util.Set"
import {$Type, $Type$$Type} from "org.objectweb.asm.Type"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModFileScanData$ClassData extends $Record {

constructor(clazz: $Type$$Type, parent: $Type$$Type, interfaces: $Set$$Type<($Type$$Type)>)

public "clazz"(): $Type
public "parent"(): $Type
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "interfaces"(): $Set<($Type)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFileScanData$ClassData$$Type = ({"parent"?: $Type$$Type, "clazz"?: $Type$$Type, "interfaces"?: $Set$$Type<($Type$$Type)>}) | ([parent?: $Type$$Type, clazz?: $Type$$Type, interfaces?: $Set$$Type<($Type$$Type)>]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFileScanData$ClassData_ = $ModFileScanData$ClassData$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerSetSpawnEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerSetSpawnEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $ResourceKey$$Type<($Level)>, arg2: $BlockPos$$Type, arg3: boolean)

public "isForced"(): boolean
public "getNewSpawn"(): $BlockPos
public "getSpawnLevel"(): $ResourceKey<($Level)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "forced"(): boolean
get "newSpawn"(): $BlockPos
get "spawnLevel"(): $ResourceKey<($Level)>
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerSetSpawnEvent$$Type = ($PlayerSetSpawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerSetSpawnEvent_ = $PlayerSetSpawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$BreakEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$BreakEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $Player$$Type)

public "setCanceled"(arg0: boolean): void
public "getPlayer"(): $Player
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "player"(): $Player
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$BreakEvent$$Type = ($BlockEvent$BreakEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$BreakEvent_ = $BlockEvent$BreakEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.damagesource.IReductionFunction" {
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"

export interface $IReductionFunction {

 "modify"(arg0: $DamageContainer$$Type, arg1: float): float

(arg0: $DamageContainer, arg1: float): float
}

export namespace $IReductionFunction {
const probejs$$marker: never
}
export class $IReductionFunction$$Static implements $IReductionFunction {


 "modify"(arg0: $DamageContainer$$Type, arg1: float): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IReductionFunction$$Type = ((arg0: $DamageContainer, arg1: float) => float);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IReductionFunction_ = $IReductionFunction$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ItemEntityPickupEvent$Post" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ItemEntityPickupEvent, $ItemEntityPickupEvent$$Type} from "net.neoforged.neoforge.event.entity.player.ItemEntityPickupEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"

export class $ItemEntityPickupEvent$Post extends $ItemEntityPickupEvent {

constructor(arg0: $Player$$Type, arg1: $ItemEntity$$Type, arg2: $ItemStack$$Type)

public "getOriginalStack"(): $ItemStack
public "getCurrentStack"(): $ItemStack
get "originalStack"(): $ItemStack
get "currentStack"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemEntityPickupEvent$Post$$Type = ($ItemEntityPickupEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemEntityPickupEvent$Post_ = $ItemEntityPickupEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.common.EffectCure" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ByteBuf, $ByteBuf$$Type} from "io.netty.buffer.ByteBuf"

export class $EffectCure {
static "CODEC": $Codec<($EffectCure)>
static readonly "STREAM_CODEC": $StreamCodec<($ByteBuf), ($EffectCure)>


public "name"(): string
public static "get"(arg0: string): $EffectCure
public "toString"(): string
public static "getAllCures"(): $Collection<($EffectCure)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EffectCure$$Type = ($EffectCure);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EffectCure_ = $EffectCure$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Render$Pre" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ScreenEvent$Render, $ScreenEvent$Render$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$Render"

export class $ScreenEvent$Render$Pre extends $ScreenEvent$Render implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer, arg4: float)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Render$Pre$$Type = ($ScreenEvent$Render$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Render$Pre_ = $ScreenEvent$Render$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerSpawnPhantomsEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerSpawnPhantomsEvent$Result, $PlayerSpawnPhantomsEvent$Result$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerSpawnPhantomsEvent$Result"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerSpawnPhantomsEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: integer)

public "setResult"(arg0: $PlayerSpawnPhantomsEvent$Result$$Type): void
public "getResult"(): $PlayerSpawnPhantomsEvent$Result
public "getPhantomsToSpawn"(): integer
public "setPhantomsToSpawn"(arg0: integer): void
public "shouldSpawnPhantoms"(arg0: $ServerLevel$$Type, arg1: $BlockPos$$Type): boolean
public "getEntity"(): $Entity
set "result"(value: $PlayerSpawnPhantomsEvent$Result$$Type)
get "result"(): $PlayerSpawnPhantomsEvent$Result
get "phantomsToSpawn"(): integer
set "phantomsToSpawn"(value: integer)
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerSpawnPhantomsEvent$$Type = ($PlayerSpawnPhantomsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerSpawnPhantomsEvent_ = $PlayerSpawnPhantomsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IVertexConsumerExtension" {
import {$PoseStack$Pose, $PoseStack$Pose$$Type} from "com.mojang.blaze3d.vertex.PoseStack$Pose"
import {$VertexFormatElement, $VertexFormatElement$$Type} from "com.mojang.blaze3d.vertex.VertexFormatElement"
import {$VertexConsumer, $VertexConsumer$$Type} from "com.mojang.blaze3d.vertex.VertexConsumer"
import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"
import {$ByteBuffer, $ByteBuffer$$Type} from "java.nio.ByteBuffer"
import {$Matrix3f, $Matrix3f$$Type} from "org.joml.Matrix3f"
import {$BakedQuad, $BakedQuad$$Type} from "net.minecraft.client.renderer.block.model.BakedQuad"

export interface $IVertexConsumerExtension {

 "putBulkData"(arg0: $PoseStack$Pose$$Type, arg1: $BakedQuad$$Type, arg2: float, arg3: float, arg4: float, arg5: float, arg6: integer, arg7: integer, arg8: boolean): void
 "applyBakedLighting"(arg0: integer, arg1: $ByteBuffer$$Type): integer
 "applyBakedNormals"(arg0: $Vector3f$$Type, arg1: $ByteBuffer$$Type, arg2: $Matrix3f$$Type): void
 "misc"(arg0: $VertexFormatElement$$Type, ...arg1: (integer)[]): $VertexConsumer
}

export namespace $IVertexConsumerExtension {
const probejs$$marker: never
}
export class $IVertexConsumerExtension$$Static implements $IVertexConsumerExtension {


 "putBulkData"(arg0: $PoseStack$Pose$$Type, arg1: $BakedQuad$$Type, arg2: float, arg3: float, arg4: float, arg5: float, arg6: integer, arg7: integer, arg8: boolean): void
 "applyBakedLighting"(arg0: integer, arg1: $ByteBuffer$$Type): integer
 "applyBakedNormals"(arg0: $Vector3f$$Type, arg1: $ByteBuffer$$Type, arg2: $Matrix3f$$Type): void
 "misc"(arg0: $VertexFormatElement$$Type, ...arg1: (integer)[]): $VertexConsumer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IVertexConsumerExtension$$Type = ($IVertexConsumerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IVertexConsumerExtension_ = $IVertexConsumerExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.ServerChatEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export class $ServerChatEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: string, arg2: $Component$$Type)

public "getMessage"(): $Component
public "getUsername"(): string
public "setMessage"(arg0: $Component$$Type): void
public "getRawText"(): string
public "getPlayer"(): $ServerPlayer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "message"(): $Component
get "username"(): string
set "message"(value: $Component$$Type)
get "rawText"(): string
get "player"(): $ServerPlayer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerChatEvent$$Type = ($ServerChatEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerChatEvent_ = $ServerChatEvent$$Type;
}}
declare module "net.neoforged.neoforge.server.command.EnumArgument$Info" {
import {$ArgumentTypeInfo$Template, $ArgumentTypeInfo$Template$$Type} from "net.minecraft.commands.synchronization.ArgumentTypeInfo$Template"
import {$EnumArgument, $EnumArgument$$Type} from "net.neoforged.neoforge.server.command.EnumArgument"
import {$ArgumentType, $ArgumentType$$Type} from "com.mojang.brigadier.arguments.ArgumentType"
import {$EnumArgument$Info$Template, $EnumArgument$Info$Template$$Type} from "net.neoforged.neoforge.server.command.EnumArgument$Info$Template"
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$FriendlyByteBuf, $FriendlyByteBuf$$Type} from "net.minecraft.network.FriendlyByteBuf"
import {$JsonObject, $JsonObject$$Type} from "com.google.gson.JsonObject"
import {$ArgumentTypeInfo, $ArgumentTypeInfo$$Type} from "net.minecraft.commands.synchronization.ArgumentTypeInfo"

export class $EnumArgument$Info<T extends $Enum<(T)>> implements $ArgumentTypeInfo<($EnumArgument<(T)>), ($EnumArgument$Info$Template<>)> {

constructor()

public "unpack"(arg0: $ArgumentType$$Type<(any)>): $ArgumentTypeInfo$Template<(any)>
public "unpack"(arg0: $EnumArgument$$Type<(T)>): $EnumArgument$Info$Template<>
public "deserializeFromNetwork"(arg0: $FriendlyByteBuf$$Type): $ArgumentTypeInfo$Template<(any)>
public "serializeToNetwork"(arg0: $ArgumentTypeInfo$Template$$Type<(any)>, arg1: $FriendlyByteBuf$$Type): void
public "serializeToNetwork"(arg0: $EnumArgument$Info$Template$$Type<>, arg1: $FriendlyByteBuf$$Type): void
public "serializeToJson"(arg0: $EnumArgument$Info$Template$$Type<>, arg1: $JsonObject$$Type): void
public "serializeToJson"(arg0: $ArgumentTypeInfo$Template$$Type<(any)>, arg1: $JsonObject$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnumArgument$Info$$Type<T> = ($EnumArgument$Info<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnumArgument$Info_<T> = $EnumArgument$Info$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.event.CalculatePlayerTurnEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $CalculatePlayerTurnEvent extends $Event {

constructor(arg0: double, arg1: boolean)

public "getCinematicCameraEnabled"(): boolean
public "getMouseSensitivity"(): double
public "setCinematicCameraEnabled"(arg0: boolean): void
public "setMouseSensitivity"(arg0: double): void
get "cinematicCameraEnabled"(): boolean
get "mouseSensitivity"(): double
set "cinematicCameraEnabled"(value: boolean)
set "mouseSensitivity"(value: double)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CalculatePlayerTurnEvent$$Type = ($CalculatePlayerTurnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CalculatePlayerTurnEvent_ = $CalculatePlayerTurnEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseInput, $ScreenEvent$MouseInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseInput"

export class $ScreenEvent$MouseButtonPressed extends $ScreenEvent$MouseInput {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer)

public "getMouseY"(): double
public "getMouseX"(): double
public "getButton"(): integer
get "mouseY"(): double
get "mouseX"(): double
get "button"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonPressed$$Type = ($ScreenEvent$MouseButtonPressed);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonPressed_ = $ScreenEvent$MouseButtonPressed$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IDispensibleContainerItemExtension" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$BlockHitResult, $BlockHitResult$$Type} from "net.minecraft.world.phys.BlockHitResult"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export interface $IDispensibleContainerItemExtension {

 "emptyContents"(arg0: $Player$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $BlockHitResult$$Type, arg4: $ItemStack$$Type): boolean
}

export namespace $IDispensibleContainerItemExtension {
const probejs$$marker: never
}
export class $IDispensibleContainerItemExtension$$Static implements $IDispensibleContainerItemExtension {


 "emptyContents"(arg0: $Player$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $BlockHitResult$$Type, arg4: $ItemStack$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IDispensibleContainerItemExtension$$Type = ($IDispensibleContainerItemExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IDispensibleContainerItemExtension_ = $IDispensibleContainerItemExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ContainerScreenEvent$Render$Background" {
import {$ContainerScreenEvent$Render, $ContainerScreenEvent$Render$$Type} from "net.neoforged.neoforge.client.event.ContainerScreenEvent$Render"
import {$AbstractContainerScreen, $AbstractContainerScreen$$Type} from "net.minecraft.client.gui.screens.inventory.AbstractContainerScreen"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"

export class $ContainerScreenEvent$Render$Background extends $ContainerScreenEvent$Render {

constructor(arg0: $AbstractContainerScreen$$Type<(any)>, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ContainerScreenEvent$Render$Background$$Type = ($ContainerScreenEvent$Render$Background);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ContainerScreenEvent$Render$Background_ = $ContainerScreenEvent$Render$Background$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyReleased$Pre" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ScreenEvent$KeyReleased, $ScreenEvent$KeyReleased$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyReleased"

export class $ScreenEvent$KeyReleased$Pre extends $ScreenEvent$KeyReleased implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyReleased$Pre$$Type = ($ScreenEvent$KeyReleased$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyReleased$Pre_ = $ScreenEvent$KeyReleased$Pre$$Type;
}}
declare module "net.neoforged.neoforge.attachment.AttachmentHolder" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$AttachmentType, $AttachmentType$$Type} from "net.neoforged.neoforge.attachment.AttachmentType"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$IAttachmentHolder, $IAttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.IAttachmentHolder"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export class $AttachmentHolder implements $IAttachmentHolder {
static readonly "ATTACHMENTS_NBT_KEY": string

constructor()

public "getData"<T>(arg0: $AttachmentType$$Type<(T)>): T
public "serializeAttachments"(arg0: $HolderLookup$Provider$$Type): $CompoundTag
public "hasData"(arg0: $AttachmentType$$Type<(any)>): boolean
public "removeData"<T>(arg0: $AttachmentType$$Type<(T)>): T
public "setData"<T>(arg0: $AttachmentType$$Type<(T)>, arg1: T): T
public "getExistingData"<T>(arg0: $AttachmentType$$Type<(T)>): $Optional<(T)>
public "hasAttachments"(): boolean
public "getData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
public "hasData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): boolean
public "removeData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
public "setData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>, arg1: T): T
public "getExistingData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): $Optional<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttachmentHolder$$Type = ($AttachmentHolder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttachmentHolder_ = $AttachmentHolder$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingBreatheEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingBreatheEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: boolean, arg2: integer, arg3: integer)

public "canBreathe"(): boolean
public "setConsumeAirAmount"(arg0: integer): void
public "setCanBreathe"(arg0: boolean): void
public "setRefillAirAmount"(arg0: integer): void
public "getConsumeAirAmount"(): integer
public "getRefillAirAmount"(): integer
set "consumeAirAmount"(value: integer)
set "refillAirAmount"(value: integer)
get "consumeAirAmount"(): integer
get "refillAirAmount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingBreatheEvent$$Type = ($LivingBreatheEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingBreatheEvent_ = $LivingBreatheEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.SoundEvent$SoundSourceEvent" {
import {$SoundEvent, $SoundEvent$$Type} from "net.neoforged.neoforge.client.event.sound.SoundEvent"
import {$SoundInstance, $SoundInstance$$Type} from "net.minecraft.client.resources.sounds.SoundInstance"
import {$Channel, $Channel$$Type} from "com.mojang.blaze3d.audio.Channel"

export class $SoundEvent$SoundSourceEvent extends $SoundEvent {


public "getName"(): string
public "getChannel"(): $Channel
public "getSound"(): $SoundInstance
get "name"(): string
get "channel"(): $Channel
get "sound"(): $SoundInstance
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SoundEvent$SoundSourceEvent$$Type = ($SoundEvent$SoundSourceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SoundEvent$SoundSourceEvent_ = $SoundEvent$SoundSourceEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkWatchEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$ChunkPos, $ChunkPos$$Type} from "net.minecraft.world.level.ChunkPos"

export class $ChunkWatchEvent extends $Event {

constructor(arg0: $ServerPlayer$$Type, arg1: $ChunkPos$$Type, arg2: $ServerLevel$$Type)

public "getLevel"(): $ServerLevel
public "getPos"(): $ChunkPos
public "getPlayer"(): $ServerPlayer
get "level"(): $ServerLevel
get "pos"(): $ChunkPos
get "player"(): $ServerPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkWatchEvent$$Type = ($ChunkWatchEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkWatchEvent_ = $ChunkWatchEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed$Post$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $ScreenEvent$MouseButtonPressed$Post$Result extends $Enum<($ScreenEvent$MouseButtonPressed$Post$Result)> {
static readonly "FORCE_HANDLED": $ScreenEvent$MouseButtonPressed$Post$Result
static readonly "FORCE_UNHANDLED": $ScreenEvent$MouseButtonPressed$Post$Result
static readonly "DEFAULT": $ScreenEvent$MouseButtonPressed$Post$Result


public static "values"(): ($ScreenEvent$MouseButtonPressed$Post$Result)[]
public static "valueOf"(arg0: string): $ScreenEvent$MouseButtonPressed$Post$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonPressed$Post$Result$$Type = (("force_handled") | ("default") | ("force_unhandled"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonPressed$Post$Result_ = $ScreenEvent$MouseButtonPressed$Post$Result$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.DataMapsUpdatedEvent" {
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$DataMapsUpdatedEvent$UpdateCause, $DataMapsUpdatedEvent$UpdateCause$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapsUpdatedEvent$UpdateCause"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $DataMapsUpdatedEvent extends $Event {

constructor(arg0: $RegistryAccess$$Type, arg1: $Registry$$Type<(any)>, arg2: $DataMapsUpdatedEvent$UpdateCause$$Type)

public "getCause"(): $DataMapsUpdatedEvent$UpdateCause
public "getRegistryKey"(): $ResourceKey<($Registry<(any)>)>
public "getRegistry"(): $Registry<(any)>
public "getRegistries"(): $RegistryAccess
public "ifRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Consumer$$Type<($Registry<(T)>)>): void
get "cause"(): $DataMapsUpdatedEvent$UpdateCause
get "registryKey"(): $ResourceKey<($Registry<(any)>)>
get "registry"(): $Registry<(any)>
get "registries"(): $RegistryAccess
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataMapsUpdatedEvent$$Type = ($DataMapsUpdatedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataMapsUpdatedEvent_ = $DataMapsUpdatedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.model.geometry.IGeometryBakingContext" {
import {$ItemTransforms, $ItemTransforms$$Type} from "net.minecraft.client.renderer.block.model.ItemTransforms"
import {$RenderTypeGroup, $RenderTypeGroup$$Type} from "net.neoforged.neoforge.client.RenderTypeGroup"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Material, $Material$$Type} from "net.minecraft.client.resources.model.Material"
import {$Transformation, $Transformation$$Type} from "com.mojang.math.Transformation"

export interface $IGeometryBakingContext {

 "getTransforms"(): $ItemTransforms
 "getMaterial"(arg0: string): $Material
 "useAmbientOcclusion"(): boolean
 "getRenderType"(arg0: $ResourceLocation$$Type): $RenderTypeGroup
 "isGui3d"(): boolean
 "getModelName"(): string
 "hasMaterial"(arg0: string): boolean
 "useBlockLight"(): boolean
 "getRenderTypeHint"(): $ResourceLocation
 "isComponentVisible"(arg0: string, arg1: boolean): boolean
 "getRootTransform"(): $Transformation
get "transforms"(): $ItemTransforms
get "gui3d"(): boolean
get "modelName"(): string
get "renderTypeHint"(): $ResourceLocation
get "rootTransform"(): $Transformation
}

export namespace $IGeometryBakingContext {
const probejs$$marker: never
}
export class $IGeometryBakingContext$$Static implements $IGeometryBakingContext {


 "getTransforms"(): $ItemTransforms
 "getMaterial"(arg0: string): $Material
 "useAmbientOcclusion"(): boolean
 "getRenderType"(arg0: $ResourceLocation$$Type): $RenderTypeGroup
 "isGui3d"(): boolean
 "getModelName"(): string
 "hasMaterial"(arg0: string): boolean
 "useBlockLight"(): boolean
 "getRenderTypeHint"(): $ResourceLocation
 "isComponentVisible"(arg0: string, arg1: boolean): boolean
 "getRootTransform"(): $Transformation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IGeometryBakingContext$$Type = ($IGeometryBakingContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IGeometryBakingContext_ = $IGeometryBakingContext$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IPackResourcesExtension" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IPackResourcesExtension {

 "isHidden"(): boolean
get "hidden"(): boolean
}

export namespace $IPackResourcesExtension {
const probejs$$marker: never
}
export class $IPackResourcesExtension$$Static implements $IPackResourcesExtension {


 "isHidden"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPackResourcesExtension$$Type = ($IPackResourcesExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPackResourcesExtension_ = $IPackResourcesExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.furnace.FurnaceFuelBurnTimeEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RecipeType, $RecipeType$$Type} from "net.minecraft.world.item.crafting.RecipeType"

export class $FurnaceFuelBurnTimeEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: integer, arg2: $RecipeType$$Type<(any)>)

public "setBurnTime"(arg0: integer): void
public "getBurnTime"(): integer
public "getRecipeType"(): $RecipeType<(any)>
public "getItemStack"(): $ItemStack
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "burnTime"(value: integer)
get "burnTime"(): integer
get "recipeType"(): $RecipeType<(any)>
get "itemStack"(): $ItemStack
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FurnaceFuelBurnTimeEvent$$Type = ($FurnaceFuelBurnTimeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FurnaceFuelBurnTimeEvent_ = $FurnaceFuelBurnTimeEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent$BossEventProgress" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Window, $Window$$Type} from "com.mojang.blaze3d.platform.Window"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LerpingBossEvent, $LerpingBossEvent$$Type} from "net.minecraft.client.gui.components.LerpingBossEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$CustomizeGuiOverlayEvent, $CustomizeGuiOverlayEvent$$Type} from "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent"

export class $CustomizeGuiOverlayEvent$BossEventProgress extends $CustomizeGuiOverlayEvent implements $ICancellableEvent {

constructor(arg0: $Window$$Type, arg1: $GuiGraphics$$Type, arg2: $DeltaTracker$$Type, arg3: $LerpingBossEvent$$Type, arg4: integer, arg5: integer, arg6: integer)

public "getY"(): integer
public "getBossEvent"(): $LerpingBossEvent
public "getIncrement"(): integer
public "setIncrement"(arg0: integer): void
public "getX"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "y"(): integer
get "bossEvent"(): $LerpingBossEvent
get "increment"(): integer
set "increment"(value: integer)
get "x"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CustomizeGuiOverlayEvent$BossEventProgress$$Type = ($CustomizeGuiOverlayEvent$BossEventProgress);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CustomizeGuiOverlayEvent$BossEventProgress_ = $CustomizeGuiOverlayEvent$BossEventProgress$$Type;
}}
declare module "net.neoforged.neoforge.client.model.data.ModelData" {
import {$ModelProperty, $ModelProperty$$Type} from "net.neoforged.neoforge.client.model.data.ModelProperty"
import {$Set, $Set$$Type} from "java.util.Set"
import {$ModelData$Builder, $ModelData$Builder$$Type} from "net.neoforged.neoforge.client.model.data.ModelData$Builder"

export class $ModelData {
static readonly "EMPTY": $ModelData


public "get"<T>(arg0: $ModelProperty$$Type<(T)>): T
public static "of"<T>(arg0: $ModelProperty$$Type<(T)>, arg1: T): $ModelData
public static "builder"(): $ModelData$Builder
public "getProperties"(): $Set<($ModelProperty<(any)>)>
public "has"(arg0: $ModelProperty$$Type<(any)>): boolean
public "derive"(): $ModelData$Builder
get "properties"(): $Set<($ModelProperty<(any)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelData$$Type = ($ModelData);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelData_ = $ModelData$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiEvent$Post" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$RenderGuiEvent, $RenderGuiEvent$$Type} from "net.neoforged.neoforge.client.event.RenderGuiEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiEvent$Post extends $RenderGuiEvent {

constructor(arg0: $GuiGraphics$$Type, arg1: $DeltaTracker$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiEvent$Post$$Type = ($RenderGuiEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiEvent$Post_ = $RenderGuiEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerNegotiationEvent" {
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Future, $Future$$Type} from "java.util.concurrent.Future"
import {$Runnable, $Runnable$$Type} from "java.lang.Runnable"
import {$GameProfile, $GameProfile$$Type} from "com.mojang.authlib.GameProfile"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export class $PlayerNegotiationEvent extends $Event {

constructor(arg0: $Connection$$Type, arg1: $GameProfile$$Type, arg2: $List$$Type<($Future$$Type<(void)>)>)

public "getConnection"(): $Connection
public "getProfile"(): $GameProfile
public "enqueueWork"(arg0: $Runnable$$Type): void
public "enqueueWork"(arg0: $Future$$Type<(void)>): void
get "connection"(): $Connection
get "profile"(): $GameProfile
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerNegotiationEvent$$Type = ($PlayerNegotiationEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerNegotiationEvent_ = $PlayerNegotiationEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.damagesource.IScalingFunction" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$Difficulty, $Difficulty$$Type} from "net.minecraft.world.Difficulty"

export interface $IScalingFunction {

 "scaleDamage"(arg0: $DamageSource$$Type, arg1: $Player$$Type, arg2: float, arg3: $Difficulty$$Type): float

(arg0: $DamageSource, arg1: $Player, arg2: float, arg3: $Difficulty): float
}

export namespace $IScalingFunction {
const DEFAULT: $IScalingFunction
const probejs$$marker: never
}
export class $IScalingFunction$$Static implements $IScalingFunction {
static readonly "DEFAULT": $IScalingFunction


 "scaleDamage"(arg0: $DamageSource$$Type, arg1: $Player$$Type, arg2: float, arg3: $Difficulty$$Type): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IScalingFunction$$Type = ((arg0: $DamageSource, arg1: $Player, arg2: float, arg3: $Difficulty) => float);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IScalingFunction_ = $IScalingFunction$$Type;
}}
declare module "net.neoforged.neoforge.network.handling.IPayloadHandler" {
import {$IPayloadContext, $IPayloadContext$$Type} from "net.neoforged.neoforge.network.handling.IPayloadContext"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"

export interface $IPayloadHandler<T extends $CustomPacketPayload> {

 "handle"(arg0: T, arg1: $IPayloadContext$$Type): void

(arg0: T, arg1: $IPayloadContext): void
}

export namespace $IPayloadHandler {
const probejs$$marker: never
}
export class $IPayloadHandler$$Static<T extends $CustomPacketPayload> implements $IPayloadHandler {


 "handle"(arg0: T, arg1: $IPayloadContext$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPayloadHandler$$Type<T> = ((arg0: T, arg1: $IPayloadContext) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPayloadHandler_<T> = $IPayloadHandler$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.level.ChunkEvent$Unload" {
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$ChunkEvent, $ChunkEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkEvent"

export class $ChunkEvent$Unload extends $ChunkEvent {

constructor(arg0: $ChunkAccess$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkEvent$Unload$$Type = ($ChunkEvent$Unload);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkEvent$Unload_ = $ChunkEvent$Unload$$Type;
}}
declare module "net.neoforged.neoforge.fluids.crafting.FluidIngredient" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$FluidIngredientType, $FluidIngredientType$$Type} from "net.neoforged.neoforge.fluids.crafting.FluidIngredientType"
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$List, $List$$Type} from "java.util.List"
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"
import {$FluidStack, $FluidStack$$Type} from "net.neoforged.neoforge.fluids.FluidStack"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$FluidIngredientKJS, $FluidIngredientKJS$$Type} from "dev.latvian.mods.kubejs.core.FluidIngredientKJS"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"

export class $FluidIngredient implements $Predicate<($FluidStack)>, $FluidIngredientKJS {
static readonly "CODEC_NON_EMPTY": $Codec<($FluidIngredient)>
static readonly "CODEC": $Codec<($FluidIngredient)>
static readonly "LIST_CODEC": $Codec<($List<($FluidIngredient)>)>
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($FluidIngredient)>
static readonly "MAP_CODEC_NONEMPTY": $MapCodec<($FluidIngredient)>
static readonly "LIST_CODEC_NON_EMPTY": $Codec<($List<($FluidIngredient)>)>

constructor()

public "isSimple"(): boolean
public "hasNoFluids"(): boolean
public "getStacks"(): ($FluidStack)[]
public "equals"(arg0: any): boolean
public "hashCode"(): integer
public "test"(arg0: any): boolean
public "test"(arg0: $FluidStack$$Type): boolean
public "isEmpty"(): boolean
public static "of"(...arg0: ($Fluid$$Type)[]): $FluidIngredient
public static "of"(): $FluidIngredient
public static "of"(...arg0: ($FluidStack$$Type)[]): $FluidIngredient
public static "single"(arg0: $Holder$$Type<($Fluid)>): $FluidIngredient
public static "single"(arg0: $FluidStack$$Type): $FluidIngredient
public static "single"(arg0: $Fluid$$Type): $FluidIngredient
public static "empty"(): $FluidIngredient
public "getType"(): $FluidIngredientType<(any)>
public static "tag"(arg0: $TagKey$$Type<($Fluid)>): $FluidIngredient
public "or"(arg0: $Predicate$$Type<($FluidStack)>): $Predicate<($FluidStack)>
public "negate"(): $Predicate<($FluidStack)>
public "and"(arg0: $Predicate$$Type<($FluidStack)>): $Predicate<($FluidStack)>
public static "not"<T>(arg0: $Predicate$$Type<($FluidStack)>): $Predicate<($FluidStack)>
public static "isEqual"<T>(arg0: any): $Predicate<($FluidStack)>
public "matches"(arg1: $FluidStack$$Type, arg2: boolean): boolean
public "matches"(arg1: $FluidIngredient$$Type, arg2: boolean): boolean
public static "wrap"(arg1: any): $ReplacementMatch
get "simple"(): boolean
get "stacks"(): ($FluidStack)[]
get "type"(): $FluidIngredientType<(any)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidIngredient$$Type = ($Fluid$$Type) | (`#${Special.FluidTag}`) | (`@${Special.Mod}`) | (RegExp);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidIngredient_ = $FluidIngredient$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.RegisterSpawnPlacementsEvent$MergedSpawnPredicate" {
import {$Heightmap$Types, $Heightmap$Types$$Type} from "net.minecraft.world.level.levelgen.Heightmap$Types"
import {$SpawnPlacements$SpawnPredicate, $SpawnPlacements$SpawnPredicate$$Type} from "net.minecraft.world.entity.SpawnPlacements$SpawnPredicate"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$SpawnPlacementType, $SpawnPlacementType$$Type} from "net.minecraft.world.entity.SpawnPlacementType"

export class $RegisterSpawnPlacementsEvent$MergedSpawnPredicate<T extends $Entity> {

constructor(arg0: $SpawnPlacements$SpawnPredicate$$Type<(T)>, arg1: $SpawnPlacementType$$Type, arg2: $Heightmap$Types$$Type)

public "build"(): $SpawnPlacements$SpawnPredicate<(T)>
public "getSpawnType"(): $SpawnPlacementType
public "getHeightmapType"(): $Heightmap$Types
get "spawnType"(): $SpawnPlacementType
get "heightmapType"(): $Heightmap$Types
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterSpawnPlacementsEvent$MergedSpawnPredicate$$Type<T> = ($RegisterSpawnPlacementsEvent$MergedSpawnPredicate<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterSpawnPlacementsEvent$MergedSpawnPredicate_<T> = $RegisterSpawnPlacementsEvent$MergedSpawnPredicate$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.event.EntityRenderersEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $EntityRenderersEvent extends $Event implements $IModBusEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityRenderersEvent$$Type = ($EntityRenderersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityRenderersEvent_ = $EntityRenderersEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent$LoggingOut" {
import {$MultiPlayerGameMode, $MultiPlayerGameMode$$Type} from "net.minecraft.client.multiplayer.MultiPlayerGameMode"
import {$LocalPlayer, $LocalPlayer$$Type} from "net.minecraft.client.player.LocalPlayer"
import {$ClientPlayerNetworkEvent, $ClientPlayerNetworkEvent$$Type} from "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export class $ClientPlayerNetworkEvent$LoggingOut extends $ClientPlayerNetworkEvent {

constructor(arg0: $MultiPlayerGameMode$$Type, arg1: $LocalPlayer$$Type, arg2: $Connection$$Type)

public "getConnection"(): $Connection
public "getMultiPlayerGameMode"(): $MultiPlayerGameMode
public "getPlayer"(): $LocalPlayer
get "connection"(): $Connection
get "multiPlayerGameMode"(): $MultiPlayerGameMode
get "player"(): $LocalPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPlayerNetworkEvent$LoggingOut$$Type = ($ClientPlayerNetworkEvent$LoggingOut);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPlayerNetworkEvent$LoggingOut_ = $ClientPlayerNetworkEvent$LoggingOut$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Render" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"

export class $ScreenEvent$Render extends $ScreenEvent {


public "getGuiGraphics"(): $GuiGraphics
public "getMouseY"(): integer
public "getMouseX"(): integer
public "getPartialTick"(): float
get "guiGraphics"(): $GuiGraphics
get "mouseY"(): integer
get "mouseX"(): integer
get "partialTick"(): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Render$$Type = ($ScreenEvent$Render);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Render_ = $ScreenEvent$Render$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerXpEvent$PickupXp" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerXpEvent, $PlayerXpEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerXpEvent"
import {$ExperienceOrb, $ExperienceOrb$$Type} from "net.minecraft.world.entity.ExperienceOrb"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerXpEvent$PickupXp extends $PlayerXpEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $ExperienceOrb$$Type)

public "getOrb"(): $ExperienceOrb
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "orb"(): $ExperienceOrb
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerXpEvent$PickupXp$$Type = ($PlayerXpEvent$PickupXp);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerXpEvent$PickupXp_ = $PlayerXpEvent$PickupXp$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Opening" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$Opening extends $ScreenEvent implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: $Screen$$Type)

public "setNewScreen"(arg0: $Screen$$Type): void
public "getCurrentScreen"(): $Screen
public "getNewScreen"(): $Screen
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "newScreen"(value: $Screen$$Type)
get "currentScreen"(): $Screen
get "newScreen"(): $Screen
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Opening$$Type = ($ScreenEvent$Opening);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Opening_ = $ScreenEvent$Opening$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IFriendlyByteBufExtension" {
import {$BiFunction, $BiFunction$$Type} from "java.util.function.BiFunction"
import {$StreamEncoder, $StreamEncoder$$Type} from "net.minecraft.network.codec.StreamEncoder"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Map, $Map$$Type} from "java.util.Map"
import {$FriendlyByteBuf, $FriendlyByteBuf$$Type} from "net.minecraft.network.FriendlyByteBuf"
import {$TriConsumer, $TriConsumer$$Type} from "org.apache.commons.lang3.function.TriConsumer"
import {$BiConsumer, $BiConsumer$$Type} from "java.util.function.BiConsumer"
import {$StreamDecoder, $StreamDecoder$$Type} from "net.minecraft.network.codec.StreamDecoder"
import {$IntFunction, $IntFunction$$Type} from "java.util.function.IntFunction"

export interface $IFriendlyByteBufExtension {

 "readArray"<T>(arg0: $IntFunction$$Type<((T)[])>, arg1: $StreamDecoder$$Type<($FriendlyByteBuf), (T)>): (T)[]
 "writeByte"(arg0: byte): $FriendlyByteBuf
 "writeObjectCollection"<T>(arg0: $Collection$$Type<(T)>, arg1: $BiConsumer$$Type<(T), ($FriendlyByteBuf)>): void
 "readMap"<K, V>(arg0: $StreamDecoder$$Type<($FriendlyByteBuf), (K)>, arg1: $BiFunction$$Type<($FriendlyByteBuf), (K), (V)>): $Map<(K), (V)>
 "writeMap"<K, V>(arg0: $Map$$Type<(K), (V)>, arg1: $StreamEncoder$$Type<($FriendlyByteBuf), (K)>, arg2: $TriConsumer$$Type<($FriendlyByteBuf), (K), (V)>): void
 "writeArray"<T>(arg0: (T)[], arg1: $StreamEncoder$$Type<($FriendlyByteBuf), (T)>): $FriendlyByteBuf
}

export namespace $IFriendlyByteBufExtension {
const probejs$$marker: never
}
export class $IFriendlyByteBufExtension$$Static implements $IFriendlyByteBufExtension {


 "readArray"<T>(arg0: $IntFunction$$Type<((T)[])>, arg1: $StreamDecoder$$Type<($FriendlyByteBuf), (T)>): (T)[]
 "writeByte"(arg0: byte): $FriendlyByteBuf
 "writeObjectCollection"<T>(arg0: $Collection$$Type<(T)>, arg1: $BiConsumer$$Type<(T), ($FriendlyByteBuf)>): void
 "readMap"<K, V>(arg0: $StreamDecoder$$Type<($FriendlyByteBuf), (K)>, arg1: $BiFunction$$Type<($FriendlyByteBuf), (K), (V)>): $Map<(K), (V)>
 "writeMap"<K, V>(arg0: $Map$$Type<(K), (V)>, arg1: $StreamEncoder$$Type<($FriendlyByteBuf), (K)>, arg2: $TriConsumer$$Type<($FriendlyByteBuf), (K), (V)>): void
 "writeArray"<T>(arg0: (T)[], arg1: $StreamEncoder$$Type<($FriendlyByteBuf), (T)>): $FriendlyByteBuf
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IFriendlyByteBufExtension$$Type = ($IFriendlyByteBufExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IFriendlyByteBufExtension_ = $IFriendlyByteBufExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.conditions.WithConditions" {
import {$List, $List$$Type} from "java.util.List"
import {$WithConditions$Builder, $WithConditions$Builder$$Type} from "net.neoforged.neoforge.common.conditions.WithConditions$Builder"
import {$ICondition, $ICondition$$Type} from "net.neoforged.neoforge.common.conditions.ICondition"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $WithConditions<A> extends $Record {

constructor(conditions: $List$$Type<($ICondition$$Type)>, carrier: A)
constructor(arg0: A)
constructor(arg0: A, ...arg1: ($ICondition$$Type)[])

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public static "builder"<A>(arg0: A): $WithConditions$Builder<(A)>
public "carrier"(): A
public "conditions"(): $List<($ICondition)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $WithConditions$$Type<A> = ({"conditions"?: $List$$Type<($ICondition$$Type)>, "carrier"?: any}) | ([conditions?: $List$$Type<($ICondition$$Type)>, carrier?: any]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $WithConditions_<A> = $WithConditions$$Type<(A)>;
}}
declare module "net.neoforged.neoforge.event.TagsUpdatedEvent$UpdateCause" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $TagsUpdatedEvent$UpdateCause extends $Enum<($TagsUpdatedEvent$UpdateCause)> {
static readonly "SERVER_DATA_LOAD": $TagsUpdatedEvent$UpdateCause
static readonly "CLIENT_PACKET_RECEIVED": $TagsUpdatedEvent$UpdateCause


public static "values"(): ($TagsUpdatedEvent$UpdateCause)[]
public static "valueOf"(arg0: string): $TagsUpdatedEvent$UpdateCause
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TagsUpdatedEvent$UpdateCause$$Type = (("server_data_load") | ("client_packet_received"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TagsUpdatedEvent$UpdateCause_ = $TagsUpdatedEvent$UpdateCause$$Type;
}}
declare module "net.neoforged.neoforge.data.event.GatherDataEvent$DataGeneratorConfig" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$CompletableFuture, $CompletableFuture$$Type} from "java.util.concurrent.CompletableFuture"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$Set, $Set$$Type} from "java.util.Set"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$DataGenerator, $DataGenerator$$Type} from "net.minecraft.data.DataGenerator"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export class $GatherDataEvent$DataGeneratorConfig {

constructor(arg0: $Set$$Type<(string)>, arg1: $Path$$Type, arg2: $Collection$$Type<($Path$$Type)>, arg3: $CompletableFuture$$Type<($HolderLookup$Provider$$Type)>, arg4: boolean, arg5: boolean, arg6: boolean, arg7: boolean, arg8: boolean, arg9: boolean)

public "getInputs"(): $Collection<($Path)>
public "isFlat"(): boolean
public "getMods"(): $Set<(string)>
public "makeGenerator"(arg0: $Function$$Type<($Path), ($Path$$Type)>, arg1: boolean): $DataGenerator
public "runAll"(): void
get "inputs"(): $Collection<($Path)>
get "flat"(): boolean
get "mods"(): $Set<(string)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GatherDataEvent$DataGeneratorConfig$$Type = ($GatherDataEvent$DataGeneratorConfig);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GatherDataEvent$DataGeneratorConfig_ = $GatherDataEvent$DataGeneratorConfig$$Type;
}}
declare module "net.neoforged.neoforge.event.ModMismatchEvent$MismatchedVersionInfo" {
import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModMismatchEvent$MismatchedVersionInfo extends $Record {

constructor(oldVersion: $ArtifactVersion$$Type, newVersion: $ArtifactVersion$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "isMissing"(): boolean
public "oldVersion"(): $ArtifactVersion
public "newVersion"(): $ArtifactVersion
public "wasUpgrade"(): boolean
get "missing"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModMismatchEvent$MismatchedVersionInfo$$Type = ({"oldVersion"?: $ArtifactVersion$$Type, "newVersion"?: $ArtifactVersion$$Type}) | ([oldVersion?: $ArtifactVersion$$Type, newVersion?: $ArtifactVersion$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModMismatchEvent$MismatchedVersionInfo_ = $ModMismatchEvent$MismatchedVersionInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.brewing.PlayerBrewedPotionEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerBrewedPotionEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type)

public "getStack"(): $ItemStack
public "getEntity"(): $Entity
get "stack"(): $ItemStack
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerBrewedPotionEvent$$Type = ($PlayerBrewedPotionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerBrewedPotionEvent_ = $PlayerBrewedPotionEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed$Pre" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ScreenEvent$MouseButtonPressed, $ScreenEvent$MouseButtonPressed$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed"

export class $ScreenEvent$MouseButtonPressed$Pre extends $ScreenEvent$MouseButtonPressed implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer)

public "getMouseY"(): double
public "getMouseX"(): double
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "mouseY"(): double
get "mouseX"(): double
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonPressed$Pre$$Type = ($ScreenEvent$MouseButtonPressed$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonPressed$Pre_ = $ScreenEvent$MouseButtonPressed$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.level.block.CropGrowEvent$Pre" {
import {$CropGrowEvent, $CropGrowEvent$$Type} from "net.neoforged.neoforge.event.level.block.CropGrowEvent"
import {$CropGrowEvent$Pre$Result, $CropGrowEvent$Pre$Result$$Type} from "net.neoforged.neoforge.event.level.block.CropGrowEvent$Pre$Result"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $CropGrowEvent$Pre extends $CropGrowEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type)

public "setResult"(arg0: $CropGrowEvent$Pre$Result$$Type): void
public "getResult"(): $CropGrowEvent$Pre$Result
set "result"(value: $CropGrowEvent$Pre$Result$$Type)
get "result"(): $CropGrowEvent$Pre$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CropGrowEvent$Pre$$Type = ($CropGrowEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CropGrowEvent$Pre_ = $CropGrowEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.server.ServerLifecycleEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerLifecycleEvent extends $Event {

constructor(arg0: $MinecraftServer$$Type)

public "getServer"(): $MinecraftServer
get "server"(): $MinecraftServer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerLifecycleEvent$$Type = ($ServerLifecycleEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerLifecycleEvent_ = $ServerLifecycleEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBlockExtension" {
import {$MapColor, $MapColor$$Type} from "net.minecraft.world.level.material.MapColor"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$ServerPlayer$RespawnPosAngle, $ServerPlayer$RespawnPosAngle$$Type} from "net.minecraft.server.level.ServerPlayer$RespawnPosAngle"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ItemAbility, $ItemAbility$$Type} from "net.neoforged.neoforge.common.ItemAbility"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BubbleColumnDirection, $BubbleColumnDirection$$Type} from "net.neoforged.neoforge.common.enums.BubbleColumnDirection"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"
import {$SoundType, $SoundType$$Type} from "net.minecraft.world.level.block.SoundType"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$TreeConfiguration, $TreeConfiguration$$Type} from "net.minecraft.world.level.levelgen.feature.configurations.TreeConfiguration"
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$SignalGetter, $SignalGetter$$Type} from "net.minecraft.world.level.SignalGetter"
import {$Rotation, $Rotation$$Type} from "net.minecraft.world.level.block.Rotation"
import {$BiConsumer, $BiConsumer$$Type} from "java.util.function.BiConsumer"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$PushReaction, $PushReaction$$Type} from "net.minecraft.world.level.material.PushReaction"

export interface $IBlockExtension {

 "isPortalFrame"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "isEmpty"(arg0: $BlockState$$Type): boolean
 "rotate"(arg0: $BlockState$$Type, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type, arg3: $Rotation$$Type): $BlockState
 "hasDynamicLightEmission"(arg0: $BlockState$$Type): boolean
 "getEnchantPowerBonus"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): float
 "getExplosionResistance"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): float
 "onDestroyedByPushReaction"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $FluidState$$Type): void
 "getStateAtViewpoint"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Vec3$$Type): $BlockState
 "collisionExtendsVertically"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "getPistonPushReaction"(arg0: $BlockState$$Type): $PushReaction
 "onDestroyedByPlayer"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type, arg4: boolean, arg5: $FluidState$$Type): boolean
 "shouldCheckWeakPower"(arg0: $BlockState$$Type, arg1: $SignalGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "getBeaconColorMultiplier"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): integer
 "shouldDisplayFluidOverlay"(arg0: $BlockState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $FluidState$$Type): boolean
 "getBubbleColumnDirection"(arg0: $BlockState$$Type): $BubbleColumnDirection
 "canDropFromExplosion"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): boolean
 "getToolModifiedState"(arg0: $BlockState$$Type, arg1: $UseOnContext$$Type, arg2: $ItemAbility$$Type, arg3: boolean): $BlockState
 "getAdjacentBlockPathType"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: $PathType$$Type): $PathType
 "isFireSource"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "getFlammability"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): integer
 "isFlammable"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "onCaughtFire"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $LivingEntity$$Type): void
 "getFireSpreadSpeed"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): integer
 "makesOpenTrapdoorAboveClimbable"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type): boolean
 "shouldHideAdjacentFluidFace"(arg0: $BlockState$$Type, arg1: $Direction$$Type, arg2: $FluidState$$Type): boolean
 "getCloneItemStack"(arg0: $BlockState$$Type, arg1: $HitResult$$Type, arg2: $LevelReader$$Type, arg3: $BlockPos$$Type, arg4: $Player$$Type): $ItemStack
 "getLightEmission"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): integer
 "getSoundType"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): $SoundType
 "getFriction"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): float
 "isStickyBlock"(arg0: $BlockState$$Type): boolean
 "hidesNeighborFace"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockState$$Type, arg4: $Direction$$Type): boolean
 "isScaffolding"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "canEntityDestroy"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "canConnectRedstone"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "canSustainPlant"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $BlockState$$Type): $TriState
 "onBlockExploded"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): void
 "getAppearance"(arg0: $BlockState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $BlockState$$Type, arg5: $BlockPos$$Type): $BlockState
 "isConduitFrame"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): boolean
 "addRunningEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "canHarvestBlock"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): boolean
 "setBedOccupied"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type, arg4: boolean): void
 "onNeighborChange"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): void
 "canBeHydrated"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $FluidState$$Type, arg4: $BlockPos$$Type): boolean
 "isSlimeBlock"(arg0: $BlockState$$Type): boolean
 "getMapColor"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $MapColor$$Type): $MapColor
 "getBedDirection"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): $Direction
 "getBlockPathType"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type): $PathType
 "onBlockStateChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockState$$Type): void
 "addLandingEffects"(arg0: $BlockState$$Type, arg1: $ServerLevel$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $LivingEntity$$Type, arg5: integer): boolean
 "getWeakChanges"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): boolean
 "getRespawnPosition"(arg0: $BlockState$$Type, arg1: $EntityType$$Type<(any)>, arg2: $LevelReader$$Type, arg3: $BlockPos$$Type, arg4: float): $Optional<($ServerPlayer$RespawnPosAngle)>
 "supportsExternalFaceHiding"(arg0: $BlockState$$Type): boolean
 "isFertile"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "onTreeGrow"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BiConsumer$$Type<($BlockPos), ($BlockState)>, arg3: $RandomSource$$Type, arg4: $BlockPos$$Type, arg5: $TreeConfiguration$$Type): boolean
 "isBurning"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "getExpDrop"(arg0: $BlockState$$Type, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type, arg3: $BlockEntity$$Type, arg4: $Entity$$Type, arg5: $ItemStack$$Type): integer
 "isLadder"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "isBed"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "canStickTo"(arg0: $BlockState$$Type, arg1: $BlockState$$Type): boolean
}

export namespace $IBlockExtension {
const probejs$$marker: never
}
export class $IBlockExtension$$Static implements $IBlockExtension {


 "isPortalFrame"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "isEmpty"(arg0: $BlockState$$Type): boolean
 "rotate"(arg0: $BlockState$$Type, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type, arg3: $Rotation$$Type): $BlockState
 "hasDynamicLightEmission"(arg0: $BlockState$$Type): boolean
 "getEnchantPowerBonus"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): float
 "getExplosionResistance"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): float
 "onDestroyedByPushReaction"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $FluidState$$Type): void
 "getStateAtViewpoint"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Vec3$$Type): $BlockState
 "collisionExtendsVertically"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "getPistonPushReaction"(arg0: $BlockState$$Type): $PushReaction
 "onDestroyedByPlayer"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type, arg4: boolean, arg5: $FluidState$$Type): boolean
 "shouldCheckWeakPower"(arg0: $BlockState$$Type, arg1: $SignalGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "getBeaconColorMultiplier"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): integer
 "shouldDisplayFluidOverlay"(arg0: $BlockState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $FluidState$$Type): boolean
 "getBubbleColumnDirection"(arg0: $BlockState$$Type): $BubbleColumnDirection
 "canDropFromExplosion"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): boolean
 "getToolModifiedState"(arg0: $BlockState$$Type, arg1: $UseOnContext$$Type, arg2: $ItemAbility$$Type, arg3: boolean): $BlockState
 "getAdjacentBlockPathType"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: $PathType$$Type): $PathType
 "isFireSource"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "getFlammability"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): integer
 "isFlammable"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "onCaughtFire"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $LivingEntity$$Type): void
 "getFireSpreadSpeed"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): integer
 "makesOpenTrapdoorAboveClimbable"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type): boolean
 "shouldHideAdjacentFluidFace"(arg0: $BlockState$$Type, arg1: $Direction$$Type, arg2: $FluidState$$Type): boolean
 "getCloneItemStack"(arg0: $BlockState$$Type, arg1: $HitResult$$Type, arg2: $LevelReader$$Type, arg3: $BlockPos$$Type, arg4: $Player$$Type): $ItemStack
 "getLightEmission"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): integer
 "getSoundType"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): $SoundType
 "getFriction"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): float
 "isStickyBlock"(arg0: $BlockState$$Type): boolean
 "hidesNeighborFace"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockState$$Type, arg4: $Direction$$Type): boolean
 "isScaffolding"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "canEntityDestroy"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "canConnectRedstone"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type): boolean
 "canSustainPlant"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $BlockState$$Type): $TriState
 "onBlockExploded"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): void
 "getAppearance"(arg0: $BlockState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $Direction$$Type, arg4: $BlockState$$Type, arg5: $BlockPos$$Type): $BlockState
 "isConduitFrame"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): boolean
 "addRunningEffects"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $Entity$$Type): boolean
 "canHarvestBlock"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): boolean
 "setBedOccupied"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type, arg4: boolean): void
 "onNeighborChange"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $BlockPos$$Type): void
 "canBeHydrated"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $FluidState$$Type, arg4: $BlockPos$$Type): boolean
 "isSlimeBlock"(arg0: $BlockState$$Type): boolean
 "getMapColor"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $MapColor$$Type): $MapColor
 "getBedDirection"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): $Direction
 "getBlockPathType"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type): $PathType
 "onBlockStateChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockState$$Type): void
 "addLandingEffects"(arg0: $BlockState$$Type, arg1: $ServerLevel$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $LivingEntity$$Type, arg5: integer): boolean
 "getWeakChanges"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): boolean
 "getRespawnPosition"(arg0: $BlockState$$Type, arg1: $EntityType$$Type<(any)>, arg2: $LevelReader$$Type, arg3: $BlockPos$$Type, arg4: float): $Optional<($ServerPlayer$RespawnPosAngle)>
 "supportsExternalFaceHiding"(arg0: $BlockState$$Type): boolean
 "isFertile"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "onTreeGrow"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BiConsumer$$Type<($BlockPos), ($BlockState)>, arg3: $RandomSource$$Type, arg4: $BlockPos$$Type, arg5: $TreeConfiguration$$Type): boolean
 "isBurning"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "getExpDrop"(arg0: $BlockState$$Type, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type, arg3: $BlockEntity$$Type, arg4: $Entity$$Type, arg5: $ItemStack$$Type): integer
 "isLadder"(arg0: $BlockState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "isBed"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $LivingEntity$$Type): boolean
 "canStickTo"(arg0: $BlockState$$Type, arg1: $BlockState$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockExtension$$Type = ($IBlockExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockExtension_ = $IBlockExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobDespawnEvent$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $MobDespawnEvent$Result extends $Enum<($MobDespawnEvent$Result)> {
static readonly "DENY": $MobDespawnEvent$Result
static readonly "ALLOW": $MobDespawnEvent$Result
static readonly "DEFAULT": $MobDespawnEvent$Result


public static "values"(): ($MobDespawnEvent$Result)[]
public static "valueOf"(arg0: string): $MobDespawnEvent$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobDespawnEvent$Result$$Type = (("allow") | ("default") | ("deny"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobDespawnEvent$Result_ = $MobDespawnEvent$Result$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseScrolled" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseInput, $ScreenEvent$MouseInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseInput"

export class $ScreenEvent$MouseScrolled extends $ScreenEvent$MouseInput {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: double, arg4: double)

public "getScrollDeltaX"(): double
public "getScrollDeltaY"(): double
public "getMouseY"(): double
public "getMouseX"(): double
get "scrollDeltaX"(): double
get "scrollDeltaY"(): double
get "mouseY"(): double
get "mouseX"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseScrolled$$Type = ($ScreenEvent$MouseScrolled);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseScrolled_ = $ScreenEvent$MouseScrolled$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ModelEvent$RegisterAdditional" {
import {$ModelEvent, $ModelEvent$$Type} from "net.neoforged.neoforge.client.event.ModelEvent"
import {$ModelResourceLocation, $ModelResourceLocation$$Type} from "net.minecraft.client.resources.model.ModelResourceLocation"
import {$Set, $Set$$Type} from "java.util.Set"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $ModelEvent$RegisterAdditional extends $ModelEvent implements $IModBusEvent {

constructor(arg0: $Set$$Type<($ModelResourceLocation$$Type)>)

public "register"(arg0: $ModelResourceLocation$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelEvent$RegisterAdditional$$Type = ($ModelEvent$RegisterAdditional);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelEvent$RegisterAdditional_ = $ModelEvent$RegisterAdditional$$Type;
}}
declare module "net.neoforged.neoforge.common.world.chunk.LoadingValidationCallback" {
import {$TicketHelper, $TicketHelper$$Type} from "net.neoforged.neoforge.common.world.chunk.TicketHelper"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"

export interface $LoadingValidationCallback {

 "validateTickets"(arg0: $ServerLevel$$Type, arg1: $TicketHelper$$Type): void

(arg0: $ServerLevel, arg1: $TicketHelper): void
}

export namespace $LoadingValidationCallback {
const probejs$$marker: never
}
export class $LoadingValidationCallback$$Static implements $LoadingValidationCallback {


 "validateTickets"(arg0: $ServerLevel$$Type, arg1: $TicketHelper$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LoadingValidationCallback$$Type = ((arg0: $ServerLevel, arg1: $TicketHelper) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LoadingValidationCallback_ = $LoadingValidationCallback$$Type;
}}
declare module "net.neoforged.neoforge.common.world.StructureSettingsBuilder$StructureSpawnOverrideBuilder" {
import {$StructureSpawnOverride$BoundingBoxType, $StructureSpawnOverride$BoundingBoxType$$Type} from "net.minecraft.world.level.levelgen.structure.StructureSpawnOverride$BoundingBoxType"
import {$List, $List$$Type} from "java.util.List"
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"
import {$MobSpawnSettings$SpawnerData, $MobSpawnSettings$SpawnerData$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings$SpawnerData"
import {$StructureSpawnOverride, $StructureSpawnOverride$$Type} from "net.minecraft.world.level.levelgen.structure.StructureSpawnOverride"

export class $StructureSettingsBuilder$StructureSpawnOverrideBuilder {


public static "copyOf"(arg0: $StructureSpawnOverride$$Type): $StructureSettingsBuilder$StructureSpawnOverrideBuilder
public "build"(): $StructureSpawnOverride
public "removeSpawn"(arg0: $MobSpawnSettings$SpawnerData$$Type): void
public "setBoundingBox"(arg0: $StructureSpawnOverride$BoundingBoxType$$Type): void
public "removeSpawns"(arg0: $Predicate$$Type<($MobSpawnSettings$SpawnerData)>): void
public "addSpawn"(arg0: $MobSpawnSettings$SpawnerData$$Type): void
public "getBoundingBox"(): $StructureSpawnOverride$BoundingBoxType
public "getSpawns"(): $List<($MobSpawnSettings$SpawnerData)>
set "boundingBox"(value: $StructureSpawnOverride$BoundingBoxType$$Type)
get "boundingBox"(): $StructureSpawnOverride$BoundingBoxType
get "spawns"(): $List<($MobSpawnSettings$SpawnerData)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StructureSettingsBuilder$StructureSpawnOverrideBuilder$$Type = ($StructureSettingsBuilder$StructureSpawnOverrideBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StructureSettingsBuilder$StructureSpawnOverrideBuilder_ = $StructureSettingsBuilder$StructureSpawnOverrideBuilder$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$MouseButton$Pre" {
import {$InputEvent$MouseButton, $InputEvent$MouseButton$$Type} from "net.neoforged.neoforge.client.event.InputEvent$MouseButton"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $InputEvent$MouseButton$Pre extends $InputEvent$MouseButton implements $ICancellableEvent {

constructor(arg0: integer, arg1: integer, arg2: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$MouseButton$Pre$$Type = ($InputEvent$MouseButton$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$MouseButton$Pre_ = $InputEvent$MouseButton$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLivingEvent" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$EntityModel, $EntityModel$$Type} from "net.minecraft.client.model.EntityModel"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityRenderer, $LivingEntityRenderer$$Type} from "net.minecraft.client.renderer.entity.LivingEntityRenderer"

export class $RenderLivingEvent<T extends $LivingEntity, M extends $EntityModel<(T)>> extends $Event {


public "getEntity"(): $LivingEntity
public "getPackedLight"(): integer
public "getRenderer"(): $LivingEntityRenderer<(T), (M)>
public "getPoseStack"(): $PoseStack
public "getPartialTick"(): float
public "getMultiBufferSource"(): $MultiBufferSource
get "entity"(): $LivingEntity
get "packedLight"(): integer
get "renderer"(): $LivingEntityRenderer<(T), (M)>
get "poseStack"(): $PoseStack
get "partialTick"(): float
get "multiBufferSource"(): $MultiBufferSource
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLivingEvent$$Type<T, M> = ($RenderLivingEvent<(T), (M)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLivingEvent_<T, M> = $RenderLivingEvent$$Type<(T), (M)>;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingConversionEvent$Pre" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingConversionEvent, $LivingConversionEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingConversionEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $LivingConversionEvent$Pre extends $LivingConversionEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $EntityType$$Type<($LivingEntity$$Type)>, arg2: $Consumer$$Type<(integer)>)

public "getOutcome"(): $EntityType<($LivingEntity)>
public "setConversionTimer"(arg0: integer): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "outcome"(): $EntityType<($LivingEntity)>
set "conversionTimer"(value: integer)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingConversionEvent$Pre$$Type = ($LivingConversionEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingConversionEvent$Pre_ = $LivingConversionEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.IClientItemExtensions" {
import {$HumanoidArm, $HumanoidArm$$Type} from "net.minecraft.world.entity.HumanoidArm"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Model, $Model$$Type} from "net.minecraft.client.model.Model"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ArmorMaterial$Layer, $ArmorMaterial$Layer$$Type} from "net.minecraft.world.item.ArmorMaterial$Layer"
import {$HumanoidModel, $HumanoidModel$$Type} from "net.minecraft.client.model.HumanoidModel"
import {$LocalPlayer, $LocalPlayer$$Type} from "net.minecraft.client.player.LocalPlayer"
import {$IClientItemExtensions$FontContext, $IClientItemExtensions$FontContext$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientItemExtensions$FontContext"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$EquipmentSlot, $EquipmentSlot$$Type} from "net.minecraft.world.entity.EquipmentSlot"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$HumanoidModel$ArmPose, $HumanoidModel$ArmPose$$Type} from "net.minecraft.client.model.HumanoidModel$ArmPose"
import {$BlockEntityWithoutLevelRenderer, $BlockEntityWithoutLevelRenderer$$Type} from "net.minecraft.client.renderer.BlockEntityWithoutLevelRenderer"

export interface $IClientItemExtensions {

 "getArmPose"(arg0: $LivingEntity$$Type, arg1: $InteractionHand$$Type, arg2: $ItemStack$$Type): $HumanoidModel$ArmPose
 "getArmorLayerTintColor"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $ArmorMaterial$Layer$$Type, arg3: integer, arg4: integer): integer
 "shouldSpreadAsEntity"(arg0: $ItemStack$$Type): boolean
 "applyForgeHandTransform"(arg0: $PoseStack$$Type, arg1: $LocalPlayer$$Type, arg2: $HumanoidArm$$Type, arg3: $ItemStack$$Type, arg4: float, arg5: float, arg6: float): boolean
 "getGenericArmorModel"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $HumanoidModel$$Type<(any)>): $Model
 "getHumanoidArmorModel"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $HumanoidModel$$Type<(any)>): $HumanoidModel<(any)>
 "setupModelAnimations"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $Model$$Type, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float, arg9: float): void
/**
 * 
 * @deprecated
 */
 "renderHelmetOverlay"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: integer, arg3: integer, arg4: float): void
 "renderHelmetOverlay"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $GuiGraphics$$Type, arg3: $DeltaTracker$$Type): void
 "shouldBobAsEntity"(arg0: $ItemStack$$Type): boolean
 "getDefaultDyeColor"(arg0: $ItemStack$$Type): integer
 "getFont"(arg0: $ItemStack$$Type, arg1: $IClientItemExtensions$FontContext$$Type): $Font
 "getCustomRenderer"(): $BlockEntityWithoutLevelRenderer
get "customRenderer"(): $BlockEntityWithoutLevelRenderer
}

export namespace $IClientItemExtensions {
const DEFAULT: $IClientItemExtensions
function of(arg0: $ItemStack$$Type): $IClientItemExtensions
function of(arg0: $Item$$Type): $IClientItemExtensions
const probejs$$marker: never
}
export class $IClientItemExtensions$$Static implements $IClientItemExtensions {
static readonly "DEFAULT": $IClientItemExtensions


static "of"(arg0: $ItemStack$$Type): $IClientItemExtensions
static "of"(arg0: $Item$$Type): $IClientItemExtensions
 "getArmPose"(arg0: $LivingEntity$$Type, arg1: $InteractionHand$$Type, arg2: $ItemStack$$Type): $HumanoidModel$ArmPose
 "getArmorLayerTintColor"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $ArmorMaterial$Layer$$Type, arg3: integer, arg4: integer): integer
 "shouldSpreadAsEntity"(arg0: $ItemStack$$Type): boolean
 "applyForgeHandTransform"(arg0: $PoseStack$$Type, arg1: $LocalPlayer$$Type, arg2: $HumanoidArm$$Type, arg3: $ItemStack$$Type, arg4: float, arg5: float, arg6: float): boolean
 "getGenericArmorModel"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $HumanoidModel$$Type<(any)>): $Model
 "getHumanoidArmorModel"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $HumanoidModel$$Type<(any)>): $HumanoidModel<(any)>
 "setupModelAnimations"(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $EquipmentSlot$$Type, arg3: $Model$$Type, arg4: float, arg5: float, arg6: float, arg7: float, arg8: float, arg9: float): void
/**
 * 
 * @deprecated
 */
 "renderHelmetOverlay"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: integer, arg3: integer, arg4: float): void
 "renderHelmetOverlay"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $GuiGraphics$$Type, arg3: $DeltaTracker$$Type): void
 "shouldBobAsEntity"(arg0: $ItemStack$$Type): boolean
 "getDefaultDyeColor"(arg0: $ItemStack$$Type): integer
 "getFont"(arg0: $ItemStack$$Type, arg1: $IClientItemExtensions$FontContext$$Type): $Font
 "getCustomRenderer"(): $BlockEntityWithoutLevelRenderer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientItemExtensions$$Type = ($IClientItemExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientItemExtensions_ = $IClientItemExtensions$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$FarmlandTrampleEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$FarmlandTrampleEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: float, arg4: $Entity$$Type)

public "getEntity"(): $Entity
public "getFallDistance"(): float
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "entity"(): $Entity
get "fallDistance"(): float
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$FarmlandTrampleEvent$$Type = ($BlockEvent$FarmlandTrampleEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$FarmlandTrampleEvent_ = $BlockEvent$FarmlandTrampleEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkTicketLevelUpdatedEvent" {
import {$ChunkHolder, $ChunkHolder$$Type} from "net.minecraft.server.level.ChunkHolder"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"

export class $ChunkTicketLevelUpdatedEvent extends $Event {

constructor(arg0: $ServerLevel$$Type, arg1: long, arg2: integer, arg3: integer, arg4: $ChunkHolder$$Type)

public "getLevel"(): $ServerLevel
public "getChunkHolder"(): $ChunkHolder
public "getNewTicketLevel"(): integer
public "getOldTicketLevel"(): integer
public "getChunkPos"(): long
get "level"(): $ServerLevel
get "chunkHolder"(): $ChunkHolder
get "newTicketLevel"(): integer
get "oldTicketLevel"(): integer
get "chunkPos"(): long
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkTicketLevelUpdatedEvent$$Type = ($ChunkTicketLevelUpdatedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkTicketLevelUpdatedEvent_ = $ChunkTicketLevelUpdatedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RecipesUpdatedEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RecipeManager, $RecipeManager$$Type} from "net.minecraft.world.item.crafting.RecipeManager"

export class $RecipesUpdatedEvent extends $Event {

constructor(arg0: $RecipeManager$$Type)

public "getRecipeManager"(): $RecipeManager
get "recipeManager"(): $RecipeManager
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RecipesUpdatedEvent$$Type = ($RecipesUpdatedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RecipesUpdatedEvent_ = $RecipesUpdatedEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableBiomeInfo$BiomeInfo$Builder" {
import {$MobSpawnSettingsBuilder, $MobSpawnSettingsBuilder$$Type} from "net.neoforged.neoforge.common.world.MobSpawnSettingsBuilder"
import {$BiomeSpecialEffectsBuilder, $BiomeSpecialEffectsBuilder$$Type} from "net.neoforged.neoforge.common.world.BiomeSpecialEffectsBuilder"
import {$ClimateSettingsBuilder, $ClimateSettingsBuilder$$Type} from "net.neoforged.neoforge.common.world.ClimateSettingsBuilder"
import {$BiomeGenerationSettingsBuilder, $BiomeGenerationSettingsBuilder$$Type} from "net.neoforged.neoforge.common.world.BiomeGenerationSettingsBuilder"
import {$ModifiableBiomeInfo$BiomeInfo, $ModifiableBiomeInfo$BiomeInfo$$Type} from "net.neoforged.neoforge.common.world.ModifiableBiomeInfo$BiomeInfo"

export class $ModifiableBiomeInfo$BiomeInfo$Builder {


public static "copyOf"(arg0: $ModifiableBiomeInfo$BiomeInfo$$Type): $ModifiableBiomeInfo$BiomeInfo$Builder
public "build"(): $ModifiableBiomeInfo$BiomeInfo
public "getClimateSettings"(): $ClimateSettingsBuilder
public "getMobSpawnSettings"(): $MobSpawnSettingsBuilder
public "getSpecialEffects"(): $BiomeSpecialEffectsBuilder
public "getGenerationSettings"(): $BiomeGenerationSettingsBuilder
get "climateSettings"(): $ClimateSettingsBuilder
get "mobSpawnSettings"(): $MobSpawnSettingsBuilder
get "specialEffects"(): $BiomeSpecialEffectsBuilder
get "generationSettings"(): $BiomeGenerationSettingsBuilder
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableBiomeInfo$BiomeInfo$Builder$$Type = ($ModifiableBiomeInfo$BiomeInfo$Builder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableBiomeInfo$BiomeInfo$Builder_ = $ModifiableBiomeInfo$BiomeInfo$Builder$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingChangeTargetEvent$ILivingTargetType" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $LivingChangeTargetEvent$ILivingTargetType {

}

export namespace $LivingChangeTargetEvent$ILivingTargetType {
const probejs$$marker: never
}
export class $LivingChangeTargetEvent$ILivingTargetType$$Static implements $LivingChangeTargetEvent$ILivingTargetType {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingChangeTargetEvent$ILivingTargetType$$Type = ($LivingChangeTargetEvent$ILivingTargetType);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingChangeTargetEvent$ILivingTargetType_ = $LivingChangeTargetEvent$ILivingTargetType$$Type;
}}
declare module "net.neoforged.neoforge.registries.DataPackRegistryEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $DataPackRegistryEvent extends $Event implements $IModBusEvent {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataPackRegistryEvent$$Type = ($DataPackRegistryEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataPackRegistryEvent_ = $DataPackRegistryEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.ArmorHurtEvent$ArmorEntry" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"

export class $ArmorHurtEvent$ArmorEntry {
readonly "originalDamage": float
 "newDamage": float
 "armorItemStack": $ItemStack

constructor(arg0: $ItemStack$$Type, arg1: float)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ArmorHurtEvent$ArmorEntry$$Type = ($ArmorHurtEvent$ArmorEntry);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ArmorHurtEvent$ArmorEntry_ = $ArmorHurtEvent$ArmorEntry$$Type;
}}
declare module "net.neoforged.neoforge.event.AnvilUpdateEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $AnvilUpdateEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: string, arg3: long, arg4: $Player$$Type)

public "getOutput"(): $ItemStack
public "getName"(): string
public "getCost"(): long
public "getLeft"(): $ItemStack
public "getRight"(): $ItemStack
public "setMaterialCost"(arg0: integer): void
public "setCost"(arg0: long): void
public "setOutput"(arg0: $ItemStack$$Type): void
public "getMaterialCost"(): integer
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "output"(): $ItemStack
get "name"(): string
get "cost"(): long
get "left"(): $ItemStack
get "right"(): $ItemStack
set "materialCost"(value: integer)
set "cost"(value: long)
set "output"(value: $ItemStack$$Type)
get "materialCost"(): integer
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnvilUpdateEvent$$Type = ($AnvilUpdateEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnvilUpdateEvent_ = $AnvilUpdateEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientChatReceivedEvent$Player" {
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$PlayerChatMessage, $PlayerChatMessage$$Type} from "net.minecraft.network.chat.PlayerChatMessage"
import {$ClientChatReceivedEvent, $ClientChatReceivedEvent$$Type} from "net.neoforged.neoforge.client.event.ClientChatReceivedEvent"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ChatType$Bound, $ChatType$Bound$$Type} from "net.minecraft.network.chat.ChatType$Bound"

export class $ClientChatReceivedEvent$Player extends $ClientChatReceivedEvent {

constructor(arg0: $ChatType$Bound$$Type, arg1: $Component$$Type, arg2: $PlayerChatMessage$$Type, arg3: $UUID$$Type)

public "getPlayerChatMessage"(): $PlayerChatMessage
get "playerChatMessage"(): $PlayerChatMessage
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientChatReceivedEvent$Player$$Type = ($ClientChatReceivedEvent$Player);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientChatReceivedEvent$Player_ = $ClientChatReceivedEvent$Player$$Type;
}}
declare module "net.neoforged.neoforge.event.CommandEvent" {
import {$ParseResults, $ParseResults$$Type} from "com.mojang.brigadier.ParseResults"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$CommandSourceStack, $CommandSourceStack$$Type} from "net.minecraft.commands.CommandSourceStack"

export class $CommandEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ParseResults$$Type<($CommandSourceStack$$Type)>)

public "getException"(): $Throwable
public "setException"(arg0: $Throwable$$Type): void
public "getParseResults"(): $ParseResults<($CommandSourceStack)>
public "setParseResults"(arg0: $ParseResults$$Type<($CommandSourceStack$$Type)>): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "exception"(): $Throwable
set "exception"(value: $Throwable$$Type)
get "parseResults"(): $ParseResults<($CommandSourceStack)>
set "parseResults"(value: $ParseResults$$Type<($CommandSourceStack$$Type)>)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CommandEvent$$Type = ($CommandEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CommandEvent_ = $CommandEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.GameShuttingDownEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $GameShuttingDownEvent extends $Event {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GameShuttingDownEvent$$Type = ($GameShuttingDownEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GameShuttingDownEvent_ = $GameShuttingDownEvent$$Type;
}}
declare module "net.neoforged.neoforge.fluids.FluidType" {
import {$FluidType$Properties, $FluidType$Properties$$Type} from "net.neoforged.neoforge.fluids.FluidType$Properties"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$FluidStack, $FluidStack$$Type} from "net.neoforged.neoforge.fluids.FluidStack"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$SoundAction, $SoundAction$$Type} from "net.neoforged.neoforge.common.SoundAction"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$Rarity, $Rarity$$Type} from "net.minecraft.world.item.Rarity"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$Lazy, $Lazy$$Type} from "net.neoforged.neoforge.common.util.Lazy"
import {$FluidType$DripstoneDripInfo, $FluidType$DripstoneDripInfo$$Type} from "net.neoforged.neoforge.fluids.FluidType$DripstoneDripInfo"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$IClientFluidTypeExtensions, $IClientFluidTypeExtensions$$Type} from "net.neoforged.neoforge.client.extensions.common.IClientFluidTypeExtensions"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$Boat, $Boat$$Type} from "net.minecraft.world.entity.vehicle.Boat"

export class $FluidType {
static readonly "SIZE": $Lazy<(integer)>
static readonly "BUCKET_VOLUME": integer

constructor(arg0: $FluidType$Properties$$Type)

public "getDescription"(arg0: $FluidStack$$Type): $Component
public "getDescription"(): $Component
public "toString"(): string
public "move"(arg0: $FluidState$$Type, arg1: $LivingEntity$$Type, arg2: $Vec3$$Type, arg3: double): boolean
public "getRarity"(): $Rarity
public "getRarity"(arg0: $FluidStack$$Type): $Rarity
public "getAdjacentBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: $PathType$$Type): $PathType
public "canRideVehicleUnder"(arg0: $Entity$$Type, arg1: $Entity$$Type): boolean
public "getFallDistanceModifier"(arg0: $Entity$$Type): float
public "getSound"(arg0: $Entity$$Type, arg1: $SoundAction$$Type): $SoundEvent
public "getSound"(arg0: $Player$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $SoundAction$$Type): $SoundEvent
public "getSound"(arg0: $FluidStack$$Type, arg1: $SoundAction$$Type): $SoundEvent
public "getSound"(arg0: $SoundAction$$Type): $SoundEvent
public "canPushEntity"(arg0: $Entity$$Type): boolean
public "motionScale"(arg0: $Entity$$Type): double
public "canExtinguish"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
public "canExtinguish"(arg0: $Entity$$Type): boolean
public "setItemMovement"(arg0: $ItemEntity$$Type): void
public "canConvertToSource"(arg0: $FluidState$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type): boolean
public "canConvertToSource"(arg0: $FluidStack$$Type): boolean
public "supportsBoating"(arg0: $FluidState$$Type, arg1: $Boat$$Type): boolean
public "supportsBoating"(arg0: $Boat$$Type): boolean
public "getStateForPlacement"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidStack$$Type): $FluidState
public "canDrownIn"(arg0: $LivingEntity$$Type): boolean
public "isVanilla"(): boolean
public "canSwim"(arg0: $Entity$$Type): boolean
public "getBucket"(arg0: $FluidStack$$Type): $ItemStack
public "getTemperature"(arg0: $FluidStack$$Type): integer
public "getTemperature"(): integer
public "getTemperature"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
public "handleCauldronDrip"(arg0: $Fluid$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
public "getDripInfo"(): $FluidType$DripstoneDripInfo
/**
 * 
 * @deprecated
 */
public "initializeClient"(arg0: $Consumer$$Type<($IClientFluidTypeExtensions)>): void
public "getBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: boolean): $PathType
public "getViscosity"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
public "getViscosity"(arg0: $FluidStack$$Type): integer
public "getViscosity"(): integer
public "getLightLevel"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
public "getLightLevel"(arg0: $FluidStack$$Type): integer
public "getLightLevel"(): integer
public "canBePlacedInLevel"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type): boolean
public "canBePlacedInLevel"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidStack$$Type): boolean
public "isLighterThanAir"(): boolean
public "getBlockForFluidState"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type): $BlockState
public "getDescriptionId"(): string
public "getDescriptionId"(arg0: $FluidStack$$Type): string
public "canHydrate"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type): boolean
public "canHydrate"(arg0: $FluidStack$$Type): boolean
public "canHydrate"(arg0: $Entity$$Type): boolean
public "isAir"(): boolean
public "isVaporizedOnPlacement"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $FluidStack$$Type): boolean
public "getDensity"(): integer
public "getDensity"(arg0: $FluidStack$$Type): integer
public "getDensity"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
public "onVaporize"(arg0: $Player$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $FluidStack$$Type): void
get "description"(): $Component
get "rarity"(): $Rarity
set "itemMovement"(value: $ItemEntity$$Type)
get "vanilla"(): boolean
get "temperature"(): integer
get "dripInfo"(): $FluidType$DripstoneDripInfo
get "viscosity"(): integer
get "lightLevel"(): integer
get "lighterThanAir"(): boolean
get "descriptionId"(): string
get "air"(): boolean
get "density"(): integer
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeFluidType
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeFluidTypeTag
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidType$$Type = (Special.NeoforgeFluidType);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidType_ = $FluidType$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseScrolled$Pre" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ScreenEvent$MouseScrolled, $ScreenEvent$MouseScrolled$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseScrolled"

export class $ScreenEvent$MouseScrolled$Pre extends $ScreenEvent$MouseScrolled implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: double, arg4: double)

public "getMouseY"(): double
public "getMouseX"(): double
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "mouseY"(): double
get "mouseX"(): double
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseScrolled$Pre$$Type = ($ScreenEvent$MouseScrolled$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseScrolled$Pre_ = $ScreenEvent$MouseScrolled$Pre$$Type;
}}
declare module "net.neoforged.neoforge.common.crafting.IngredientType" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$ICustomIngredient, $ICustomIngredient$$Type} from "net.neoforged.neoforge.common.crafting.ICustomIngredient"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $IngredientType<T extends $ICustomIngredient> extends $Record {

constructor(arg0: $MapCodec$$Type<(T)>)
constructor(codec: $MapCodec$$Type<(T)>, streamCodec: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (T)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "streamCodec"(): $StreamCodec<($RegistryFriendlyByteBuf), (T)>
public "codec"(): $MapCodec<(T)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeIngredientSerializer
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeIngredientSerializerTag
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IngredientType$$Type<T> = (Special.NeoforgeIngredientSerializer) | ({"streamCodec"?: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (any)>, "codec"?: $MapCodec$$Type<(any)>}) | ([streamCodec?: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (any)>, codec?: $MapCodec$$Type<(any)>]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IngredientType_<T> = $IngredientType$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$LoadFromFile" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$File, $File$$Type} from "java.io.File"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$LoadFromFile extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $File$$Type, arg2: string)

public "getEntity"(): $LivingEntity
public "getPlayerUUID"(): string
public "getPlayerDirectory"(): $File
public "getPlayerFile"(arg0: string): $File
get "entity"(): $LivingEntity
get "playerUUID"(): string
get "playerDirectory"(): $File
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$LoadFromFile$$Type = ($PlayerEvent$LoadFromFile);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$LoadFromFile_ = $PlayerEvent$LoadFromFile$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AdvancementEvent$AdvancementProgressEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AdvancementEvent$AdvancementProgressEvent$ProgressType, $AdvancementEvent$AdvancementProgressEvent$ProgressType$$Type} from "net.neoforged.neoforge.event.entity.player.AdvancementEvent$AdvancementProgressEvent$ProgressType"
import {$AdvancementEvent, $AdvancementEvent$$Type} from "net.neoforged.neoforge.event.entity.player.AdvancementEvent"
import {$AdvancementHolder, $AdvancementHolder$$Type} from "net.minecraft.advancements.AdvancementHolder"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$AdvancementProgress, $AdvancementProgress$$Type} from "net.minecraft.advancements.AdvancementProgress"

export class $AdvancementEvent$AdvancementProgressEvent extends $AdvancementEvent {

constructor(arg0: $Player$$Type, arg1: $AdvancementHolder$$Type, arg2: $AdvancementProgress$$Type, arg3: string, arg4: $AdvancementEvent$AdvancementProgressEvent$ProgressType$$Type)

public "getCriterionName"(): string
public "getProgressType"(): $AdvancementEvent$AdvancementProgressEvent$ProgressType
public "getAdvancementProgress"(): $AdvancementProgress
public "getEntity"(): $Entity
get "criterionName"(): string
get "progressType"(): $AdvancementEvent$AdvancementProgressEvent$ProgressType
get "advancementProgress"(): $AdvancementProgress
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AdvancementEvent$AdvancementProgressEvent$$Type = ($AdvancementEvent$AdvancementProgressEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AdvancementEvent$AdvancementProgressEvent_ = $AdvancementEvent$AdvancementProgressEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ItemEntityPickupEvent$Pre" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemEntityPickupEvent, $ItemEntityPickupEvent$$Type} from "net.neoforged.neoforge.event.entity.player.ItemEntityPickupEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"

export class $ItemEntityPickupEvent$Pre extends $ItemEntityPickupEvent {

constructor(arg0: $Player$$Type, arg1: $ItemEntity$$Type)

public "canPickup"(): $TriState
public "setCanPickup"(arg0: $TriState$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemEntityPickupEvent$Pre$$Type = ($ItemEntityPickupEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemEntityPickupEvent$Pre_ = $ItemEntityPickupEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IDimensionSpecialEffectsExtension" {
import {$ClientLevel, $ClientLevel$$Type} from "net.minecraft.client.multiplayer.ClientLevel"
import {$LightTexture, $LightTexture$$Type} from "net.minecraft.client.renderer.LightTexture"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"
import {$Runnable, $Runnable$$Type} from "java.lang.Runnable"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$Matrix4f, $Matrix4f$$Type} from "org.joml.Matrix4f"

export interface $IDimensionSpecialEffectsExtension {

 "renderClouds"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $PoseStack$$Type, arg4: double, arg5: double, arg6: double, arg7: $Matrix4f$$Type, arg8: $Matrix4f$$Type): boolean
 "adjustLightmapColors"(arg0: $ClientLevel$$Type, arg1: float, arg2: float, arg3: float, arg4: float, arg5: integer, arg6: integer, arg7: $Vector3f$$Type): void
 "renderSnowAndRain"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $LightTexture$$Type, arg4: double, arg5: double, arg6: double): boolean
 "tickRain"(arg0: $ClientLevel$$Type, arg1: integer, arg2: $Camera$$Type): boolean
 "renderSky"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $Matrix4f$$Type, arg4: $Camera$$Type, arg5: $Matrix4f$$Type, arg6: boolean, arg7: $Runnable$$Type): boolean
}

export namespace $IDimensionSpecialEffectsExtension {
const probejs$$marker: never
}
export class $IDimensionSpecialEffectsExtension$$Static implements $IDimensionSpecialEffectsExtension {


 "renderClouds"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $PoseStack$$Type, arg4: double, arg5: double, arg6: double, arg7: $Matrix4f$$Type, arg8: $Matrix4f$$Type): boolean
 "adjustLightmapColors"(arg0: $ClientLevel$$Type, arg1: float, arg2: float, arg3: float, arg4: float, arg5: integer, arg6: integer, arg7: $Vector3f$$Type): void
 "renderSnowAndRain"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $LightTexture$$Type, arg4: double, arg5: double, arg6: double): boolean
 "tickRain"(arg0: $ClientLevel$$Type, arg1: integer, arg2: $Camera$$Type): boolean
 "renderSky"(arg0: $ClientLevel$$Type, arg1: integer, arg2: float, arg3: $Matrix4f$$Type, arg4: $Camera$$Type, arg5: $Matrix4f$$Type, arg6: boolean, arg7: $Runnable$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IDimensionSpecialEffectsExtension$$Type = ($IDimensionSpecialEffectsExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IDimensionSpecialEffectsExtension_ = $IDimensionSpecialEffectsExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEquipmentChangeEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$EquipmentSlot, $EquipmentSlot$$Type} from "net.minecraft.world.entity.EquipmentSlot"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingEquipmentChangeEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $EquipmentSlot$$Type, arg2: $ItemStack$$Type, arg3: $ItemStack$$Type)

public "getSlot"(): $EquipmentSlot
public "getFrom"(): $ItemStack
public "getTo"(): $ItemStack
get "slot"(): $EquipmentSlot
get "from"(): $ItemStack
get "to"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEquipmentChangeEvent$$Type = ($LivingEquipmentChangeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEquipmentChangeEvent_ = $LivingEquipmentChangeEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.EntityTickEvent$Post" {
import {$EntityTickEvent, $EntityTickEvent$$Type} from "net.neoforged.neoforge.event.tick.EntityTickEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTickEvent$Post extends $EntityTickEvent {

constructor(arg0: $Entity$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTickEvent$Post$$Type = ($EntityTickEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTickEvent$Post_ = $EntityTickEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$PlayerChangeGameModeEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$GameType, $GameType$$Type} from "net.minecraft.world.level.GameType"

export class $PlayerEvent$PlayerChangeGameModeEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $GameType$$Type, arg2: $GameType$$Type)

public "getEntity"(): $LivingEntity
public "setNewGameMode"(arg0: $GameType$$Type): void
public "getCurrentGameMode"(): $GameType
public "getNewGameMode"(): $GameType
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "entity"(): $LivingEntity
set "newGameMode"(value: $GameType$$Type)
get "currentGameMode"(): $GameType
get "newGameMode"(): $GameType
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$PlayerChangeGameModeEvent$$Type = ($PlayerEvent$PlayerChangeGameModeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$PlayerChangeGameModeEvent_ = $PlayerEvent$PlayerChangeGameModeEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkEvent" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $ChunkEvent extends $LevelEvent {

constructor(arg0: $ChunkAccess$$Type)
constructor(arg0: $ChunkAccess$$Type, arg1: $LevelAccessor$$Type)

public "getChunk"(): $ChunkAccess
get "chunk"(): $ChunkAccess
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkEvent$$Type = ($ChunkEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkEvent_ = $ChunkEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientChatReceivedEvent$System" {
import {$ClientChatReceivedEvent, $ClientChatReceivedEvent$$Type} from "net.neoforged.neoforge.client.event.ClientChatReceivedEvent"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export class $ClientChatReceivedEvent$System extends $ClientChatReceivedEvent {

constructor(arg0: $Component$$Type, arg1: boolean)

public "isOverlay"(): boolean
get "overlay"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientChatReceivedEvent$System$$Type = ($ClientChatReceivedEvent$System);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientChatReceivedEvent$System_ = $ClientChatReceivedEvent$System$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyPressed$Post" {
import {$ScreenEvent$KeyPressed, $ScreenEvent$KeyPressed$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyPressed"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$KeyPressed$Post extends $ScreenEvent$KeyPressed implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyPressed$Post$$Type = ($ScreenEvent$KeyPressed$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyPressed$Post_ = $ScreenEvent$KeyPressed$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.CriticalHitEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $CriticalHitEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Entity$$Type, arg2: float, arg3: boolean)

public "getTarget"(): $Entity
public "getDamageMultiplier"(): float
public "isCriticalHit"(): boolean
public "disableSweep"(): boolean
public "getVanillaMultiplier"(): float
public "setDamageMultiplier"(arg0: float): void
public "setCriticalHit"(arg0: boolean): void
public "isVanillaCritical"(): boolean
public "setDisableSweep"(arg0: boolean): void
public "getEntity"(): $Entity
get "target"(): $Entity
get "damageMultiplier"(): float
get "criticalHit"(): boolean
get "vanillaMultiplier"(): float
set "damageMultiplier"(value: float)
set "criticalHit"(value: boolean)
get "vanillaCritical"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CriticalHitEvent$$Type = ($CriticalHitEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CriticalHitEvent_ = $CriticalHitEvent$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.ItemCapability" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$List, $List$$Type} from "java.util.List"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$BaseCapability, $BaseCapability$$Type} from "net.neoforged.neoforge.capabilities.BaseCapability"

export class $ItemCapability<T, C> extends $BaseCapability<(T), (C)> {


public static "create"<T, C>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>, arg2: $Class$$Type<(C)>): $ItemCapability<(T), (C)>
public static "getAll"(): $List<($ItemCapability<(any), (any)>)>
public "getCapability"(arg0: $ItemStack$$Type, arg1: C): T
public static "createVoid"<T>(arg0: $ResourceLocation$$Type, arg1: $Class$$Type<(T)>): $ItemCapability<(T), (void)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemCapability$$Type<T, C> = ($ItemCapability<(T), (C)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemCapability_<T, C> = $ItemCapability$$Type<(T), (C)>;
}}
declare module "net.neoforged.neoforge.client.event.RenderTooltipEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"
import {$ClientTooltipComponent, $ClientTooltipComponent$$Type} from "net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent"

export class $RenderTooltipEvent extends $Event {


public "getY"(): integer
public "getGraphics"(): $GuiGraphics
public "getComponents"(): $List<($ClientTooltipComponent)>
public "getItemStack"(): $ItemStack
public "getFont"(): $Font
public "getX"(): integer
get "y"(): integer
get "graphics"(): $GuiGraphics
get "components"(): $List<($ClientTooltipComponent)>
get "itemStack"(): $ItemStack
get "font"(): $Font
get "x"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderTooltipEvent$$Type = ($RenderTooltipEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderTooltipEvent_ = $RenderTooltipEvent$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.events.PermissionGatherEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $PermissionGatherEvent extends $Event {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionGatherEvent$$Type = ($PermissionGatherEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionGatherEvent_ = $PermissionGatherEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkDataEvent$Load" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$ChunkDataEvent, $ChunkDataEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkDataEvent"
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$ChunkType, $ChunkType$$Type} from "net.minecraft.world.level.chunk.status.ChunkType"

export class $ChunkDataEvent$Load extends $ChunkDataEvent {

constructor(arg0: $ChunkAccess$$Type, arg1: $CompoundTag$$Type, arg2: $ChunkType$$Type)

public "getType"(): $ChunkType
get "type"(): $ChunkType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkDataEvent$Load$$Type = ($ChunkDataEvent$Load);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkDataEvent$Load_ = $ChunkDataEvent$Load$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent$TeleportCommand" {
import {$EntityTeleportEvent, $EntityTeleportEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityTeleportEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTeleportEvent$TeleportCommand extends $EntityTeleportEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: double, arg2: double, arg3: double)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$TeleportCommand$$Type = ($EntityTeleportEvent$TeleportCommand);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent$TeleportCommand_ = $EntityTeleportEvent$TeleportCommand$$Type;
}}
declare module "net.neoforged.neoforge.event.village.VillagerTradesEvent" {
import {$VillagerProfession, $VillagerProfession$$Type} from "net.minecraft.world.entity.npc.VillagerProfession"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$VillagerTrades$ItemListing, $VillagerTrades$ItemListing$$Type} from "net.minecraft.world.entity.npc.VillagerTrades$ItemListing"
import {$Int2ObjectMap, $Int2ObjectMap$$Type} from "it.unimi.dsi.fastutil.ints.Int2ObjectMap"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $VillagerTradesEvent extends $Event {

/**
 * 
 * @deprecated
 */
constructor(arg0: $Int2ObjectMap$$Type<($List$$Type<($VillagerTrades$ItemListing$$Type)>)>, arg1: $VillagerProfession$$Type)
constructor(arg0: $Int2ObjectMap$$Type<($List$$Type<($VillagerTrades$ItemListing$$Type)>)>, arg1: $VillagerProfession$$Type, arg2: $RegistryAccess$$Type)

public "getType"(): $VillagerProfession
public "getRegistryAccess"(): $RegistryAccess
public "getTrades"(): $Int2ObjectMap<($List<($VillagerTrades$ItemListing)>)>
get "type"(): $VillagerProfession
get "registryAccess"(): $RegistryAccess
get "trades"(): $Int2ObjectMap<($List<($VillagerTrades$ItemListing)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VillagerTradesEvent$$Type = ($VillagerTradesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VillagerTradesEvent_ = $VillagerTradesEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBlockAndTintGetterExtension" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IBlockAndTintGetterExtension {

 "getShade"(arg0: float, arg1: float, arg2: float, arg3: boolean): float
}

export namespace $IBlockAndTintGetterExtension {
const probejs$$marker: never
}
export class $IBlockAndTintGetterExtension$$Static implements $IBlockAndTintGetterExtension {


 "getShade"(arg0: float, arg1: float, arg2: float, arg3: boolean): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockAndTintGetterExtension$$Type = ($IBlockAndTintGetterExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockAndTintGetterExtension_ = $IBlockAndTintGetterExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.IClientFluidTypeExtensions" {
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$VertexConsumer, $VertexConsumer$$Type} from "com.mojang.blaze3d.vertex.VertexConsumer"
import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"
import {$FluidStack, $FluidStack$$Type} from "net.neoforged.neoforge.fluids.FluidStack"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$FogShape, $FogShape$$Type} from "com.mojang.blaze3d.shaders.FogShape"
import {$ClientLevel, $ClientLevel$$Type} from "net.minecraft.client.multiplayer.ClientLevel"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$Minecraft, $Minecraft$$Type} from "net.minecraft.client.Minecraft"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$FogRenderer$FogMode, $FogRenderer$FogMode$$Type} from "net.minecraft.client.renderer.FogRenderer$FogMode"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IClientFluidTypeExtensions {

 "getStillTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getStillTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getStillTexture"(): $ResourceLocation
 "renderOverlay"(arg0: $Minecraft$$Type, arg1: $PoseStack$$Type): void
 "modifyFogRender"(arg0: $Camera$$Type, arg1: $FogRenderer$FogMode$$Type, arg2: float, arg3: float, arg4: float, arg5: float, arg6: $FogShape$$Type): void
 "getFlowingTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getFlowingTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getFlowingTexture"(): $ResourceLocation
 "modifyFogColor"(arg0: $Camera$$Type, arg1: float, arg2: $ClientLevel$$Type, arg3: integer, arg4: float, arg5: $Vector3f$$Type): $Vector3f
 "renderFluid"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $VertexConsumer$$Type, arg4: $BlockState$$Type): boolean
 "getTintColor"(): integer
 "getTintColor"(arg0: $FluidStack$$Type): integer
 "getTintColor"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
 "getOverlayTexture"(): $ResourceLocation
 "getOverlayTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getOverlayTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getRenderOverlayTexture"(arg0: $Minecraft$$Type): $ResourceLocation
get "stillTexture"(): $ResourceLocation
get "flowingTexture"(): $ResourceLocation
get "tintColor"(): integer
get "overlayTexture"(): $ResourceLocation
}

export namespace $IClientFluidTypeExtensions {
const DEFAULT: $IClientFluidTypeExtensions
function of(arg0: $FluidState$$Type): $IClientFluidTypeExtensions
function of(arg0: $FluidType$$Type): $IClientFluidTypeExtensions
function of(arg0: $Fluid$$Type): $IClientFluidTypeExtensions
const probejs$$marker: never
}
export class $IClientFluidTypeExtensions$$Static implements $IClientFluidTypeExtensions {
static readonly "DEFAULT": $IClientFluidTypeExtensions


static "of"(arg0: $FluidState$$Type): $IClientFluidTypeExtensions
static "of"(arg0: $FluidType$$Type): $IClientFluidTypeExtensions
static "of"(arg0: $Fluid$$Type): $IClientFluidTypeExtensions
 "getStillTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getStillTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getStillTexture"(): $ResourceLocation
 "renderOverlay"(arg0: $Minecraft$$Type, arg1: $PoseStack$$Type): void
 "modifyFogRender"(arg0: $Camera$$Type, arg1: $FogRenderer$FogMode$$Type, arg2: float, arg3: float, arg4: float, arg5: float, arg6: $FogShape$$Type): void
 "getFlowingTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getFlowingTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getFlowingTexture"(): $ResourceLocation
 "modifyFogColor"(arg0: $Camera$$Type, arg1: float, arg2: $ClientLevel$$Type, arg3: integer, arg4: float, arg5: $Vector3f$$Type): $Vector3f
 "renderFluid"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type, arg3: $VertexConsumer$$Type, arg4: $BlockState$$Type): boolean
 "getTintColor"(): integer
 "getTintColor"(arg0: $FluidStack$$Type): integer
 "getTintColor"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): integer
 "getOverlayTexture"(): $ResourceLocation
 "getOverlayTexture"(arg0: $FluidStack$$Type): $ResourceLocation
 "getOverlayTexture"(arg0: $FluidState$$Type, arg1: $BlockAndTintGetter$$Type, arg2: $BlockPos$$Type): $ResourceLocation
 "getRenderOverlayTexture"(arg0: $Minecraft$$Type): $ResourceLocation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientFluidTypeExtensions$$Type = ($IClientFluidTypeExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientFluidTypeExtensions_ = $IClientFluidTypeExtensions$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IKeyMappingExtension" {
import {$KeyModifier, $KeyModifier$$Type} from "net.neoforged.neoforge.client.settings.KeyModifier"
import {$IKeyConflictContext, $IKeyConflictContext$$Type} from "net.neoforged.neoforge.client.settings.IKeyConflictContext"
import {$InputConstants$Key, $InputConstants$Key$$Type} from "com.mojang.blaze3d.platform.InputConstants$Key"
import {$KeyMapping, $KeyMapping$$Type} from "net.minecraft.client.KeyMapping"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export interface $IKeyMappingExtension {

 "getKey"(): $InputConstants$Key
 "getDisplayName"(): $Component
 "isActiveAndMatches"(arg0: $InputConstants$Key$$Type): boolean
 "getKeyModifier"(): $KeyModifier
 "setToDefault"(): void
 "isConflictContextAndModifierActive"(): boolean
 "getKeyConflictContext"(): $IKeyConflictContext
 "setKeyConflictContext"(arg0: $IKeyConflictContext$$Type): void
 "setKeyModifierAndCode"(arg0: $KeyModifier$$Type, arg1: $InputConstants$Key$$Type): void
 "hasKeyModifierConflict"(arg0: $KeyMapping$$Type): boolean
 "getDefaultKeyModifier"(): $KeyModifier
get "key"(): $InputConstants$Key
get "displayName"(): $Component
get "keyModifier"(): $KeyModifier
get "conflictContextAndModifierActive"(): boolean
get "keyConflictContext"(): $IKeyConflictContext
set "keyConflictContext"(value: $IKeyConflictContext$$Type)
get "defaultKeyModifier"(): $KeyModifier
}

export namespace $IKeyMappingExtension {
const probejs$$marker: never
}
export class $IKeyMappingExtension$$Static implements $IKeyMappingExtension {


 "getKey"(): $InputConstants$Key
 "getDisplayName"(): $Component
 "isActiveAndMatches"(arg0: $InputConstants$Key$$Type): boolean
 "getKeyModifier"(): $KeyModifier
 "setToDefault"(): void
 "isConflictContextAndModifierActive"(): boolean
 "getKeyConflictContext"(): $IKeyConflictContext
 "setKeyConflictContext"(arg0: $IKeyConflictContext$$Type): void
 "setKeyModifierAndCode"(arg0: $KeyModifier$$Type, arg1: $InputConstants$Key$$Type): void
 "hasKeyModifierConflict"(arg0: $KeyMapping$$Type): boolean
 "getDefaultKeyModifier"(): $KeyModifier
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IKeyMappingExtension$$Type = ($IKeyMappingExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IKeyMappingExtension_ = $IKeyMappingExtension$$Type;
}}
declare module "net.neoforged.fml.common.asm.enumextension.NetworkedEnum$NetworkCheck" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $NetworkedEnum$NetworkCheck extends $Enum<($NetworkedEnum$NetworkCheck)> {
static readonly "CLIENTBOUND": $NetworkedEnum$NetworkCheck
static readonly "BIDIRECTIONAL": $NetworkedEnum$NetworkCheck
static readonly "SERVERBOUND": $NetworkedEnum$NetworkCheck


public static "values"(): ($NetworkedEnum$NetworkCheck)[]
public static "valueOf"(arg0: string): $NetworkedEnum$NetworkCheck
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NetworkedEnum$NetworkCheck$$Type = (("clientbound") | ("serverbound") | ("bidirectional"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NetworkedEnum$NetworkCheck_ = $NetworkedEnum$NetworkCheck$$Type;
}}
declare module "net.neoforged.neoforge.client.model.data.ModelDataManager" {
import {$SectionPos, $SectionPos$$Type} from "net.minecraft.core.SectionPos"
import {$Long2ObjectMap, $Long2ObjectMap$$Type} from "it.unimi.dsi.fastutil.longs.Long2ObjectMap"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$ChunkEvent$Unload, $ChunkEvent$Unload$$Type} from "net.neoforged.neoforge.event.level.ChunkEvent$Unload"
import {$ModelData, $ModelData$$Type} from "net.neoforged.neoforge.client.model.data.ModelData"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$Long2ObjectFunction, $Long2ObjectFunction$$Type} from "it.unimi.dsi.fastutil.longs.Long2ObjectFunction"

export class $ModelDataManager {
static readonly "EMPTY_SNAPSHOT": $Long2ObjectFunction<($ModelData)>

constructor(arg0: $Level$$Type)

public "requestRefresh"(arg0: $BlockEntity$$Type): void
public static "onChunkUnload"(arg0: $ChunkEvent$Unload$$Type): void
public "snapshotSectionRegion"(arg0: integer, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer): $Long2ObjectFunction<($ModelData)>
public "getAt"(arg0: $BlockPos$$Type): $ModelData
public "getAt"(arg0: $SectionPos$$Type): $Long2ObjectMap<($ModelData)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelDataManager$$Type = ($ModelDataManager);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelDataManager_ = $ModelDataManager$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent$ChorusFruit" {
import {$EntityTeleportEvent, $EntityTeleportEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityTeleportEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $EntityTeleportEvent$ChorusFruit extends $EntityTeleportEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: double, arg2: double, arg3: double)

public "getEntityLiving"(): $LivingEntity
get "entityLiving"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$ChorusFruit$$Type = ($EntityTeleportEvent$ChorusFruit);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent$ChorusFruit_ = $EntityTeleportEvent$ChorusFruit$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityMountEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityMountEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: $Entity$$Type, arg2: $Level$$Type, arg3: boolean)

public "getLevel"(): $Level
public "isMounting"(): boolean
public "getEntityMounting"(): $Entity
public "isDismounting"(): boolean
public "getEntityBeingMounted"(): $Entity
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "level"(): $Level
get "mounting"(): boolean
get "entityMounting"(): $Entity
get "dismounting"(): boolean
get "entityBeingMounted"(): $Entity
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityMountEvent$$Type = ($EntityMountEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityMountEvent_ = $EntityMountEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.StatAwardEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Stat, $Stat$$Type} from "net.minecraft.stats.Stat"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $StatAwardEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $Stat$$Type<(any)>, arg2: integer)

public "getValue"(): integer
public "setValue"(arg0: integer): void
public "setStat"(arg0: $Stat$$Type<(any)>): void
public "getStat"(): $Stat<(any)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "value"(): integer
set "value"(value: integer)
set "stat"(value: $Stat$$Type<(any)>)
get "stat"(): $Stat<(any)>
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StatAwardEvent$$Type = ($StatAwardEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StatAwardEvent_ = $StatAwardEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerContainerEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerContainerEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $AbstractContainerMenu$$Type)

public "getContainer"(): $AbstractContainerMenu
public "getEntity"(): $Entity
get "container"(): $AbstractContainerMenu
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerContainerEvent$$Type = ($PlayerContainerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerContainerEvent_ = $PlayerContainerEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ItemFishedEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$FishingHook, $FishingHook$$Type} from "net.minecraft.world.entity.projectile.FishingHook"
import {$List, $List$$Type} from "java.util.List"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$NonNullList, $NonNullList$$Type} from "net.minecraft.core.NonNullList"

export class $ItemFishedEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $List$$Type<($ItemStack$$Type)>, arg1: integer, arg2: $FishingHook$$Type)

public "getRodDamage"(): integer
public "getDrops"(): $NonNullList<($ItemStack)>
public "getHookEntity"(): $FishingHook
public "damageRodBy"(arg0: integer): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "rodDamage"(): integer
get "drops"(): $NonNullList<($ItemStack)>
get "hookEntity"(): $FishingHook
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemFishedEvent$$Type = ($ItemFishedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemFishedEvent_ = $ItemFishedEvent$$Type;
}}
declare module "net.neoforged.neoforge.network.IContainerFactory" {
import {$MenuType$MenuSupplier, $MenuType$MenuSupplier$$Type} from "net.minecraft.world.inventory.MenuType$MenuSupplier"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$Inventory, $Inventory$$Type} from "net.minecraft.world.entity.player.Inventory"

export interface $IContainerFactory<T extends $AbstractContainerMenu> extends $MenuType$MenuSupplier<(T)> {

 "create"(arg0: integer, arg1: $Inventory$$Type, arg2: $RegistryFriendlyByteBuf$$Type): T
 "create"(arg0: integer, arg1: $Inventory$$Type): T

(arg0: integer, arg1: $Inventory, arg2: $RegistryFriendlyByteBuf): T
}

export namespace $IContainerFactory {
const probejs$$marker: never
}
export class $IContainerFactory$$Static<T extends $AbstractContainerMenu> implements $IContainerFactory {


 "create"(arg0: integer, arg1: $Inventory$$Type, arg2: $RegistryFriendlyByteBuf$$Type): T
 "create"(arg0: integer, arg1: $Inventory$$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IContainerFactory$$Type<T> = ((arg0: integer, arg1: $Inventory, arg2: $RegistryFriendlyByteBuf) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IContainerFactory_<T> = $IContainerFactory$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$HarvestCheck" {
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $PlayerEvent$HarvestCheck extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $BlockState$$Type, arg2: $BlockGetter$$Type, arg3: $BlockPos$$Type, arg4: boolean)

public "getLevel"(): $BlockGetter
public "getEntity"(): $LivingEntity
public "canHarvest"(): boolean
public "setCanHarvest"(arg0: boolean): void
public "getTargetBlock"(): $BlockState
public "getPos"(): $BlockPos
get "level"(): $BlockGetter
get "entity"(): $LivingEntity
get "targetBlock"(): $BlockState
get "pos"(): $BlockPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$HarvestCheck$$Type = ($PlayerEvent$HarvestCheck);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$HarvestCheck_ = $PlayerEvent$HarvestCheck$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerFlyableFallEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerFlyableFallEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: float, arg2: float)

public "getMultiplier"(): float
public "setMultiplier"(arg0: float): void
public "setDistance"(arg0: float): void
public "getDistance"(): float
public "getEntity"(): $Entity
get "multiplier"(): float
set "multiplier"(value: float)
set "distance"(value: float)
get "distance"(): float
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerFlyableFallEvent$$Type = ($PlayerFlyableFallEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerFlyableFallEvent_ = $PlayerFlyableFallEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$BreakSpeed" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $PlayerEvent$BreakSpeed extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $BlockState$$Type, arg2: float, arg3: $BlockPos$$Type)

public "getPosition"(): $Optional<($BlockPos)>
public "getState"(): $BlockState
public "getEntity"(): $LivingEntity
public "getNewSpeed"(): float
public "setNewSpeed"(arg0: float): void
public "getOriginalSpeed"(): float
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "position"(): $Optional<($BlockPos)>
get "state"(): $BlockState
get "entity"(): $LivingEntity
get "newSpeed"(): float
set "newSpeed"(value: float)
get "originalSpeed"(): float
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$BreakSpeed$$Type = ($PlayerEvent$BreakSpeed);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$BreakSpeed_ = $PlayerEvent$BreakSpeed$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$TabListNameFormat" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export class $PlayerEvent$TabListNameFormat extends $PlayerEvent {

constructor(arg0: $Player$$Type)

public "getDisplayName"(): $Component
public "getEntity"(): $LivingEntity
public "setDisplayName"(arg0: $Component$$Type): void
get "displayName"(): $Component
get "entity"(): $LivingEntity
set "displayName"(value: $Component$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$TabListNameFormat$$Type = ($PlayerEvent$TabListNameFormat);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$TabListNameFormat_ = $PlayerEvent$TabListNameFormat$$Type;
}}
declare module "net.neoforged.neoforge.attachment.AttachmentHolder$AsField" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$IAttachmentHolder, $IAttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.IAttachmentHolder"
import {$AttachmentHolder, $AttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.AttachmentHolder"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export class $AttachmentHolder$AsField extends $AttachmentHolder {
static readonly "ATTACHMENTS_NBT_KEY": string

constructor(arg0: $IAttachmentHolder$$Type)

public "deserializeInternal"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttachmentHolder$AsField$$Type = ($AttachmentHolder$AsField);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttachmentHolder$AsField_ = $AttachmentHolder$AsField$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingGetProjectileEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingGetProjectileEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: $ItemStack$$Type)

public "getProjectileWeaponItemStack"(): $ItemStack
public "setProjectileItemStack"(arg0: $ItemStack$$Type): void
public "getProjectileItemStack"(): $ItemStack
get "projectileWeaponItemStack"(): $ItemStack
set "projectileItemStack"(value: $ItemStack$$Type)
get "projectileItemStack"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingGetProjectileEvent$$Type = ($LivingGetProjectileEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingGetProjectileEvent_ = $LivingGetProjectileEvent$$Type;
}}
declare module "net.neoforged.neoforge.fluids.FluidType$DripstoneDripInfo" {
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$ParticleOptions, $ParticleOptions$$Type} from "net.minecraft.core.particles.ParticleOptions"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $FluidType$DripstoneDripInfo extends $Record {

constructor(chance: float, dripParticle: $ParticleOptions$$Type, filledCauldron: $Block$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "chance"(): float
public "dripParticle"(): $ParticleOptions
public "filledCauldron"(): $Block
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidType$DripstoneDripInfo$$Type = ({"dripParticle"?: $ParticleOptions$$Type, "filledCauldron"?: $Block$$Type, "chance"?: float}) | ([dripParticle?: $ParticleOptions$$Type, filledCauldron?: $Block$$Type, chance?: float]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidType$DripstoneDripInfo_ = $FluidType$DripstoneDripInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.brewing.PotionBrewEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $PotionBrewEvent extends $Event {


public "getLength"(): integer
public "getItem"(arg0: integer): $ItemStack
public "setItem"(arg0: integer, arg1: $ItemStack$$Type): void
get "length"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PotionBrewEvent$$Type = ($PotionBrewEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PotionBrewEvent_ = $PotionBrewEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.MobSpawnSettingsBuilder" {
import {$MobSpawnSettings, $MobSpawnSettings$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings"
import {$MobCategory, $MobCategory$$Type} from "net.minecraft.world.entity.MobCategory"
import {$List, $List$$Type} from "java.util.List"
import {$MobSpawnSettings$Builder, $MobSpawnSettings$Builder$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings$Builder"
import {$Set, $Set$$Type} from "java.util.Set"
import {$MobSpawnSettings$SpawnerData, $MobSpawnSettings$SpawnerData$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings$SpawnerData"
import {$MobSpawnSettings$MobSpawnCost, $MobSpawnSettings$MobSpawnCost$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings$MobSpawnCost"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $MobSpawnSettingsBuilder extends $MobSpawnSettings$Builder {

constructor(arg0: $MobSpawnSettings$$Type)

public "getCost"(arg0: $EntityType$$Type<(any)>): $MobSpawnSettings$MobSpawnCost
public "disablePlayerSpawn"(): $MobSpawnSettingsBuilder
public "getProbability"(): float
public "getSpawner"(arg0: $MobCategory$$Type): $List<($MobSpawnSettings$SpawnerData)>
public "removeSpawnCost"(...arg0: ($EntityType$$Type<(any)>)[]): $MobSpawnSettingsBuilder
public "getEntityTypes"(): $Set<($EntityType<(any)>)>
public "getSpawnerTypes"(): $Set<($MobCategory)>
get "probability"(): float
get "entityTypes"(): $Set<($EntityType<(any)>)>
get "spawnerTypes"(): $Set<($MobCategory)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnSettingsBuilder$$Type = ($MobSpawnSettingsBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnSettingsBuilder_ = $MobSpawnSettingsBuilder$$Type;
}}
declare module "net.neoforged.neoforge.event.enchanting.EnchantmentLevelSetEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export class $EnchantmentLevelSetEvent extends $Event {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: integer, arg3: integer, arg4: $ItemStack$$Type, arg5: integer)

public "getLevel"(): $Level
public "getItem"(): $ItemStack
public "getPower"(): integer
public "getEnchantLevel"(): integer
public "getOriginalLevel"(): integer
public "getEnchantRow"(): integer
public "setEnchantLevel"(arg0: integer): void
public "getPos"(): $BlockPos
get "level"(): $Level
get "item"(): $ItemStack
get "power"(): integer
get "enchantLevel"(): integer
get "originalLevel"(): integer
get "enchantRow"(): integer
set "enchantLevel"(value: integer)
get "pos"(): $BlockPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnchantmentLevelSetEvent$$Type = ($EnchantmentLevelSetEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnchantmentLevelSetEvent_ = $EnchantmentLevelSetEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IServerCommonPacketListenerExtension" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$CrashReport, $CrashReport$$Type} from "net.minecraft.CrashReport"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$PacketSendListener, $PacketSendListener$$Type} from "net.minecraft.network.PacketSendListener"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$DisconnectionDetails, $DisconnectionDetails$$Type} from "net.minecraft.network.DisconnectionDetails"
import {$ConnectionType, $ConnectionType$$Type} from "net.neoforged.neoforge.network.connection.ConnectionType"
import {$Exception, $Exception$$Type} from "java.lang.Exception"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$ICommonPacketListener, $ICommonPacketListener$$Type} from "net.neoforged.neoforge.common.extensions.ICommonPacketListener"
import {$ReentrantBlockableEventLoop, $ReentrantBlockableEventLoop$$Type} from "net.minecraft.util.thread.ReentrantBlockableEventLoop"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$CrashReportCategory, $CrashReportCategory$$Type} from "net.minecraft.CrashReportCategory"

export interface $IServerCommonPacketListenerExtension extends $ICommonPacketListener {

 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
get "connection"(): $Connection
get "connectionType"(): $ConnectionType
get "mainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
get "acceptingMessages"(): boolean
}

export namespace $IServerCommonPacketListenerExtension {
const probejs$$marker: never
}
export class $IServerCommonPacketListenerExtension$$Static implements $IServerCommonPacketListenerExtension {


 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IServerCommonPacketListenerExtension$$Type = ($IServerCommonPacketListenerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IServerCommonPacketListenerExtension_ = $IServerCommonPacketListenerExtension$$Type;
}}
declare module "net.neoforged.neoforge.fluids.FluidType$Properties" {
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$Rarity, $Rarity$$Type} from "net.minecraft.world.item.Rarity"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$ParticleOptions, $ParticleOptions$$Type} from "net.minecraft.core.particles.ParticleOptions"
import {$SoundAction, $SoundAction$$Type} from "net.neoforged.neoforge.common.SoundAction"

export class $FluidType$Properties {


public static "create"(): $FluidType$Properties
public "canPushEntity"(arg0: boolean): $FluidType$Properties
public "motionScale"(arg0: double): $FluidType$Properties
public "canExtinguish"(arg0: boolean): $FluidType$Properties
public "canConvertToSource"(arg0: boolean): $FluidType$Properties
public "supportsBoating"(arg0: boolean): $FluidType$Properties
public "temperature"(arg0: integer): $FluidType$Properties
public "lightLevel"(arg0: integer): $FluidType$Properties
public "canSwim"(arg0: boolean): $FluidType$Properties
public "rarity"(arg0: $Rarity$$Type): $FluidType$Properties
public "descriptionId"(arg0: string): $FluidType$Properties
public "adjacentPathType"(arg0: $PathType$$Type): $FluidType$Properties
public "fallDistanceModifier"(arg0: float): $FluidType$Properties
public "canHydrate"(arg0: boolean): $FluidType$Properties
public "addDripstoneDripping"(arg0: float, arg1: $ParticleOptions$$Type, arg2: $Block$$Type, arg3: $SoundEvent$$Type): $FluidType$Properties
public "sound"(arg0: $SoundAction$$Type, arg1: $SoundEvent$$Type): $FluidType$Properties
public "density"(arg0: integer): $FluidType$Properties
public "viscosity"(arg0: integer): $FluidType$Properties
public "pathType"(arg0: $PathType$$Type): $FluidType$Properties
public "canDrown"(arg0: boolean): $FluidType$Properties
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidType$Properties$$Type = ($FluidType$Properties);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidType$Properties_ = $FluidType$Properties$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IServerConfigurationPacketListenerExtension" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$ConfigurationTask$Type, $ConfigurationTask$Type$$Type} from "net.minecraft.server.network.ConfigurationTask$Type"
import {$CrashReport, $CrashReport$$Type} from "net.minecraft.CrashReport"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$PacketSendListener, $PacketSendListener$$Type} from "net.minecraft.network.PacketSendListener"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$DisconnectionDetails, $DisconnectionDetails$$Type} from "net.minecraft.network.DisconnectionDetails"
import {$ConnectionType, $ConnectionType$$Type} from "net.neoforged.neoforge.network.connection.ConnectionType"
import {$IServerCommonPacketListenerExtension, $IServerCommonPacketListenerExtension$$Type} from "net.neoforged.neoforge.common.extensions.IServerCommonPacketListenerExtension"
import {$Exception, $Exception$$Type} from "java.lang.Exception"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$ReentrantBlockableEventLoop, $ReentrantBlockableEventLoop$$Type} from "net.minecraft.util.thread.ReentrantBlockableEventLoop"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$CrashReportCategory, $CrashReportCategory$$Type} from "net.minecraft.CrashReportCategory"

export interface $IServerConfigurationPacketListenerExtension extends $IServerCommonPacketListenerExtension {

 "finishCurrentTask"(arg0: $ConfigurationTask$Type$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
get "connection"(): $Connection
get "connectionType"(): $ConnectionType
get "mainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
get "acceptingMessages"(): boolean
}

export namespace $IServerConfigurationPacketListenerExtension {
const probejs$$marker: never
}
export class $IServerConfigurationPacketListenerExtension$$Static implements $IServerConfigurationPacketListenerExtension {


 "finishCurrentTask"(arg0: $ConfigurationTask$Type$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IServerConfigurationPacketListenerExtension$$Type = ($IServerConfigurationPacketListenerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IServerConfigurationPacketListenerExtension_ = $IServerConfigurationPacketListenerExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.util.INBTSerializable" {
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $INBTSerializable<T extends $Tag> {

 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): T
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: T): void
}

export namespace $INBTSerializable {
const probejs$$marker: never
}
export class $INBTSerializable$$Static<T extends $Tag> implements $INBTSerializable {


 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): T
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: T): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $INBTSerializable$$Type<T> = ($INBTSerializable<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $INBTSerializable_<T> = $INBTSerializable$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.model.geometry.BlockGeometryBakingContext" {
import {$TextureAtlasSprite, $TextureAtlasSprite$$Type} from "net.minecraft.client.renderer.texture.TextureAtlasSprite"
import {$BlockGeometryBakingContext$VisibilityData, $BlockGeometryBakingContext$VisibilityData$$Type} from "net.neoforged.neoforge.client.model.geometry.BlockGeometryBakingContext$VisibilityData"
import {$Material, $Material$$Type} from "net.minecraft.client.resources.model.Material"
import {$ItemOverrides, $ItemOverrides$$Type} from "net.minecraft.client.renderer.block.model.ItemOverrides"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$BlockModel, $BlockModel$$Type} from "net.minecraft.client.renderer.block.model.BlockModel"
import {$IGeometryBakingContext, $IGeometryBakingContext$$Type} from "net.neoforged.neoforge.client.model.geometry.IGeometryBakingContext"
import {$ModelState, $ModelState$$Type} from "net.minecraft.client.resources.model.ModelState"
import {$ItemTransforms, $ItemTransforms$$Type} from "net.minecraft.client.renderer.block.model.ItemTransforms"
import {$RenderTypeGroup, $RenderTypeGroup$$Type} from "net.neoforged.neoforge.client.RenderTypeGroup"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Transformation, $Transformation$$Type} from "com.mojang.math.Transformation"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$ModelBaker, $ModelBaker$$Type} from "net.minecraft.client.resources.model.ModelBaker"
import {$IUnbakedGeometry, $IUnbakedGeometry$$Type} from "net.neoforged.neoforge.client.model.geometry.IUnbakedGeometry"

export class $BlockGeometryBakingContext implements $IGeometryBakingContext {
readonly "owner": $BlockModel
readonly "visibilityData": $BlockGeometryBakingContext$VisibilityData

constructor(arg0: $BlockModel$$Type)

public "copyFrom"(arg0: $BlockGeometryBakingContext$$Type): void
public "setCustomGeometry"(arg0: $IUnbakedGeometry$$Type<(any)>): void
public "setRenderTypeHint"(arg0: $ResourceLocation$$Type): void
public "setRootTransform"(arg0: $Transformation$$Type): void
public "getTransforms"(): $ItemTransforms
public "getMaterial"(arg0: string): $Material
public "useAmbientOcclusion"(): boolean
public "bake"(arg0: $ModelBaker$$Type, arg1: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>, arg2: $ModelState$$Type, arg3: $ItemOverrides$$Type): $BakedModel
public "setGui3d"(arg0: boolean): void
public "isGui3d"(): boolean
public "getModelName"(): string
public "hasMaterial"(arg0: string): boolean
public "useBlockLight"(): boolean
public "getCustomGeometry"(): $IUnbakedGeometry<(any)>
public "getRenderTypeHint"(): $ResourceLocation
public "isComponentVisible"(arg0: string, arg1: boolean): boolean
public "hasCustomGeometry"(): boolean
public "getRootTransform"(): $Transformation
public "getRenderType"(arg0: $ResourceLocation$$Type): $RenderTypeGroup
set "customGeometry"(value: $IUnbakedGeometry$$Type<(any)>)
set "renderTypeHint"(value: $ResourceLocation$$Type)
set "rootTransform"(value: $Transformation$$Type)
get "transforms"(): $ItemTransforms
set "gui3d"(value: boolean)
get "gui3d"(): boolean
get "modelName"(): string
get "customGeometry"(): $IUnbakedGeometry<(any)>
get "renderTypeHint"(): $ResourceLocation
get "rootTransform"(): $Transformation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockGeometryBakingContext$$Type = ($BlockGeometryBakingContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockGeometryBakingContext_ = $BlockGeometryBakingContext$$Type;
}}
declare module "net.neoforged.neoforge.registries.IdMappingEvent" {
import {$IdMappingEvent$IdRemapping, $IdMappingEvent$IdRemapping$$Type} from "net.neoforged.neoforge.registries.IdMappingEvent$IdRemapping"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ImmutableSet, $ImmutableSet$$Type} from "com.google.common.collect.ImmutableSet"
import {$ImmutableList, $ImmutableList$$Type} from "com.google.common.collect.ImmutableList"
import {$IdMappingEvent$ModRemapping, $IdMappingEvent$ModRemapping$$Type} from "net.neoforged.neoforge.registries.IdMappingEvent$ModRemapping"

export class $IdMappingEvent extends $Event {

constructor(arg0: $Map$$Type<($ResourceLocation$$Type), ($Map$$Type<($ResourceLocation$$Type), ($IdMappingEvent$IdRemapping$$Type)>)>, arg1: boolean)

public "isFrozen"(): boolean
public "getRegistries"(): $ImmutableSet<($ResourceLocation)>
public "getRemaps"(arg0: $ResourceLocation$$Type): $ImmutableList<($IdMappingEvent$ModRemapping)>
get "frozen"(): boolean
get "registries"(): $ImmutableSet<($ResourceLocation)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IdMappingEvent$$Type = ($IdMappingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IdMappingEvent_ = $IdMappingEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$PositionCheck$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $MobSpawnEvent$PositionCheck$Result extends $Enum<($MobSpawnEvent$PositionCheck$Result)> {
static readonly "SUCCEED": $MobSpawnEvent$PositionCheck$Result
static readonly "DEFAULT": $MobSpawnEvent$PositionCheck$Result
static readonly "FAIL": $MobSpawnEvent$PositionCheck$Result


public static "values"(): ($MobSpawnEvent$PositionCheck$Result)[]
public static "valueOf"(arg0: string): $MobSpawnEvent$PositionCheck$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnEvent$PositionCheck$Result$$Type = (("succeed") | ("default") | ("fail"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnEvent$PositionCheck$Result_ = $MobSpawnEvent$PositionCheck$Result$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLevelStageEvent$Stage" {
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"

export class $RenderLevelStageEvent$Stage {
static readonly "AFTER_WEATHER": $RenderLevelStageEvent$Stage
static readonly "AFTER_SKY": $RenderLevelStageEvent$Stage
static readonly "AFTER_CUTOUT_BLOCKS": $RenderLevelStageEvent$Stage
static readonly "AFTER_TRANSLUCENT_BLOCKS": $RenderLevelStageEvent$Stage
static readonly "AFTER_SOLID_BLOCKS": $RenderLevelStageEvent$Stage
static readonly "AFTER_TRIPWIRE_BLOCKS": $RenderLevelStageEvent$Stage
static readonly "AFTER_LEVEL": $RenderLevelStageEvent$Stage
static readonly "AFTER_BLOCK_ENTITIES": $RenderLevelStageEvent$Stage
static readonly "AFTER_ENTITIES": $RenderLevelStageEvent$Stage
static readonly "AFTER_PARTICLES": $RenderLevelStageEvent$Stage
static readonly "AFTER_CUTOUT_MIPPED_BLOCKS_BLOCKS": $RenderLevelStageEvent$Stage


public "toString"(): string
public static "fromRenderType"(arg0: $RenderType$$Type): $RenderLevelStageEvent$Stage
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLevelStageEvent$Stage$$Type = ($RenderLevelStageEvent$Stage);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLevelStageEvent$Stage_ = $RenderLevelStageEvent$Stage$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.RegisterDataMapTypesEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$DataMapType, $DataMapType$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterDataMapTypesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceKey$$Type<($Registry$$Type<(any)>)>), ($Map$$Type<($ResourceLocation$$Type), ($DataMapType$$Type<(any), (any)>)>)>)

public "register"<T, R>(arg0: $DataMapType$$Type<(R), (T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterDataMapTypesEvent$$Type = ($RegisterDataMapTypesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterDataMapTypesEvent_ = $RegisterDataMapTypesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ViewportEvent$ComputeFov" {
import {$GameRenderer, $GameRenderer$$Type} from "net.minecraft.client.renderer.GameRenderer"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$ViewportEvent, $ViewportEvent$$Type} from "net.neoforged.neoforge.client.event.ViewportEvent"

export class $ViewportEvent$ComputeFov extends $ViewportEvent {

constructor(arg0: $GameRenderer$$Type, arg1: $Camera$$Type, arg2: double, arg3: double, arg4: boolean)

public "usedConfiguredFov"(): boolean
public "getFOV"(): double
public "setFOV"(arg0: double): void
get "fOV"(): double
set "fOV"(value: double)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ViewportEvent$ComputeFov$$Type = ($ViewportEvent$ComputeFov);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ViewportEvent$ComputeFov_ = $ViewportEvent$ComputeFov$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterEntitySpectatorShadersEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $RegisterEntitySpectatorShadersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($EntityType$$Type<(any)>), ($ResourceLocation$$Type)>)

public "register"(arg0: $EntityType$$Type<(any)>, arg1: $ResourceLocation$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterEntitySpectatorShadersEvent$$Type = ($RegisterEntitySpectatorShadersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterEntitySpectatorShadersEvent_ = $RegisterEntitySpectatorShadersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityStruckByLightningEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$LightningBolt, $LightningBolt$$Type} from "net.minecraft.world.entity.LightningBolt"

export class $EntityStruckByLightningEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: $LightningBolt$$Type)

public "getLightning"(): $LightningBolt
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "lightning"(): $LightningBolt
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityStruckByLightningEvent$$Type = ($EntityStruckByLightningEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityStruckByLightningEvent_ = $EntityStruckByLightningEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.model.data.ModelProperty" {
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"

export class $ModelProperty<T> implements $Predicate<(T)> {

constructor()
constructor(arg0: $Predicate$$Type<(T)>)

public "test"(arg0: T): boolean
public "or"(arg0: $Predicate$$Type<(T)>): $Predicate<(T)>
public "negate"(): $Predicate<(T)>
public "and"(arg0: $Predicate$$Type<(T)>): $Predicate<(T)>
public static "not"<T>(arg0: $Predicate$$Type<(T)>): $Predicate<(T)>
public static "isEqual"<T>(arg0: any): $Predicate<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelProperty$$Type<T> = ($ModelProperty<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelProperty_<T> = $ModelProperty$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$RightClickItem" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerInteractEvent$RightClickItem extends $PlayerInteractEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $InteractionHand$$Type)

public "getCancellationResult"(): $InteractionResult
public "setCancellationResult"(arg0: $InteractionResult$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "cancellationResult"(): $InteractionResult
set "cancellationResult"(value: $InteractionResult$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$RightClickItem$$Type = ($PlayerInteractEvent$RightClickItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$RightClickItem_ = $PlayerInteractEvent$RightClickItem$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.UseItemOnBlockEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$UseItemOnBlockEvent$UsePhase, $UseItemOnBlockEvent$UsePhase$$Type} from "net.neoforged.neoforge.event.entity.player.UseItemOnBlockEvent$UsePhase"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$LogicalSide, $LogicalSide$$Type} from "net.neoforged.fml.LogicalSide"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemInteractionResult, $ItemInteractionResult$$Type} from "net.minecraft.world.ItemInteractionResult"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export class $UseItemOnBlockEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $UseOnContext$$Type, arg1: $UseItemOnBlockEvent$UsePhase$$Type)

public "getLevel"(): $Level
public "getCancellationResult"(): $ItemInteractionResult
public "getUseOnContext"(): $UseOnContext
public "cancelWithResult"(arg0: $ItemInteractionResult$$Type): void
public "getUsePhase"(): $UseItemOnBlockEvent$UsePhase
public "getSide"(): $LogicalSide
public "getItemStack"(): $ItemStack
public "getHand"(): $InteractionHand
public "getFace"(): $Direction
public "setCancellationResult"(arg0: $ItemInteractionResult$$Type): void
public "getPos"(): $BlockPos
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "level"(): $Level
get "cancellationResult"(): $ItemInteractionResult
get "useOnContext"(): $UseOnContext
get "usePhase"(): $UseItemOnBlockEvent$UsePhase
get "side"(): $LogicalSide
get "itemStack"(): $ItemStack
get "hand"(): $InteractionHand
get "face"(): $Direction
set "cancellationResult"(value: $ItemInteractionResult$$Type)
get "pos"(): $BlockPos
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UseItemOnBlockEvent$$Type = ($UseItemOnBlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UseItemOnBlockEvent_ = $UseItemOnBlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiEvent$Pre" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$RenderGuiEvent, $RenderGuiEvent$$Type} from "net.neoforged.neoforge.client.event.RenderGuiEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiEvent$Pre extends $RenderGuiEvent implements $ICancellableEvent {

constructor(arg0: $GuiGraphics$$Type, arg1: $DeltaTracker$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiEvent$Pre$$Type = ($RenderGuiEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiEvent$Pre_ = $RenderGuiEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ItemTooltipEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$List, $List$$Type} from "java.util.List"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$Item$TooltipContext, $Item$TooltipContext$$Type} from "net.minecraft.world.item.Item$TooltipContext"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"

export class $ItemTooltipEvent extends $PlayerEvent {

constructor(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $List$$Type<($Component$$Type)>, arg3: $TooltipFlag$$Type, arg4: $Item$TooltipContext$$Type)

public "getContext"(): $Item$TooltipContext
public "getFlags"(): $TooltipFlag
public "getEntity"(): $LivingEntity
public "getToolTip"(): $List<($Component)>
public "getItemStack"(): $ItemStack
get "context"(): $Item$TooltipContext
get "flags"(): $TooltipFlag
get "entity"(): $LivingEntity
get "toolTip"(): $List<($Component)>
get "itemStack"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemTooltipEvent$$Type = ($ItemTooltipEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemTooltipEvent_ = $ItemTooltipEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent$Item" {
import {$BlockColors, $BlockColors$$Type} from "net.minecraft.client.color.block.BlockColors"
import {$ItemColors, $ItemColors$$Type} from "net.minecraft.client.color.item.ItemColors"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$RegisterColorHandlersEvent, $RegisterColorHandlersEvent$$Type} from "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent"
import {$ItemColor, $ItemColor$$Type} from "net.minecraft.client.color.item.ItemColor"

export class $RegisterColorHandlersEvent$Item extends $RegisterColorHandlersEvent {

constructor(arg0: $ItemColors$$Type, arg1: $BlockColors$$Type)

public "register"(arg0: $ItemColor$$Type, ...arg1: ($ItemLike$$Type)[]): void
public "getBlockColors"(): $BlockColors
public "getItemColors"(): $ItemColors
get "blockColors"(): $BlockColors
get "itemColors"(): $ItemColors
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterColorHandlersEvent$Item$$Type = ($RegisterColorHandlersEvent$Item);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterColorHandlersEvent$Item_ = $RegisterColorHandlersEvent$Item$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterItemDecorationsEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$List, $List$$Type} from "java.util.List"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$IItemDecorator, $IItemDecorator$$Type} from "net.neoforged.neoforge.client.IItemDecorator"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterItemDecorationsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($Item$$Type), ($List$$Type<($IItemDecorator$$Type)>)>)

public "register"(arg0: $ItemLike$$Type, arg1: $IItemDecorator$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterItemDecorationsEvent$$Type = ($RegisterItemDecorationsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterItemDecorationsEvent_ = $RegisterItemDecorationsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.server.ServerStoppingEvent" {
import {$ServerLifecycleEvent, $ServerLifecycleEvent$$Type} from "net.neoforged.neoforge.event.server.ServerLifecycleEvent"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerStoppingEvent extends $ServerLifecycleEvent {

constructor(arg0: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerStoppingEvent$$Type = ($ServerStoppingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerStoppingEvent_ = $ServerStoppingEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModInfo$ModVersion" {
import {$IModInfo$DependencySide, $IModInfo$DependencySide$$Type} from "net.neoforged.neoforgespi.language.IModInfo$DependencySide"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$IModInfo$DependencyType, $IModInfo$DependencyType$$Type} from "net.neoforged.neoforgespi.language.IModInfo$DependencyType"
import {$URL, $URL$$Type} from "java.net.URL"
import {$IModInfo$Ordering, $IModInfo$Ordering$$Type} from "net.neoforged.neoforgespi.language.IModInfo$Ordering"
import {$VersionRange, $VersionRange$$Type} from "org.apache.maven.artifact.versioning.VersionRange"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"

export interface $IModInfo$ModVersion {

 "getReason"(): $Optional<(string)>
 "getType"(): $IModInfo$DependencyType
 "getOwner"(): $IModInfo
 "setOwner"(arg0: $IModInfo$$Type): void
 "getModId"(): string
 "getSide"(): $IModInfo$DependencySide
 "getReferralURL"(): $Optional<($URL)>
 "getOrdering"(): $IModInfo$Ordering
 "getVersionRange"(): $VersionRange
get "reason"(): $Optional<(string)>
get "type"(): $IModInfo$DependencyType
get "owner"(): $IModInfo
set "owner"(value: $IModInfo$$Type)
get "modId"(): string
get "side"(): $IModInfo$DependencySide
get "referralURL"(): $Optional<($URL)>
get "ordering"(): $IModInfo$Ordering
get "versionRange"(): $VersionRange
}

export namespace $IModInfo$ModVersion {
const probejs$$marker: never
}
export class $IModInfo$ModVersion$$Static implements $IModInfo$ModVersion {


 "getReason"(): $Optional<(string)>
 "getType"(): $IModInfo$DependencyType
 "getOwner"(): $IModInfo
 "setOwner"(arg0: $IModInfo$$Type): void
 "getModId"(): string
 "getSide"(): $IModInfo$DependencySide
 "getReferralURL"(): $Optional<($URL)>
 "getOrdering"(): $IModInfo$Ordering
 "getVersionRange"(): $VersionRange
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModInfo$ModVersion$$Type = ($IModInfo$ModVersion);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModInfo$ModVersion_ = $IModInfo$ModVersion$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyInput" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"

export class $ScreenEvent$KeyInput extends $ScreenEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyInput$$Type = ($ScreenEvent$KeyInput);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyInput_ = $ScreenEvent$KeyInput$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDamageEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"

export class $LivingDamageEvent extends $LivingEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDamageEvent$$Type = ($LivingDamageEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDamageEvent_ = $LivingDamageEvent$$Type;
}}
declare module "net.neoforged.neoforge.attachment.IAttachmentSerializer" {
import {$IAttachmentHolder, $IAttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.IAttachmentHolder"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $IAttachmentSerializer<S extends $Tag, T> {

 "write"(arg0: T, arg1: $HolderLookup$Provider$$Type): S
 "read"(arg0: $IAttachmentHolder$$Type, arg1: S, arg2: $HolderLookup$Provider$$Type): T
}

export namespace $IAttachmentSerializer {
const probejs$$marker: never
}
export class $IAttachmentSerializer$$Static<S extends $Tag, T> implements $IAttachmentSerializer {


 "write"(arg0: T, arg1: $HolderLookup$Provider$$Type): S
 "read"(arg0: $IAttachmentHolder$$Type, arg1: S, arg2: $HolderLookup$Provider$$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAttachmentSerializer$$Type<S, T> = ($IAttachmentSerializer<(S), (T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAttachmentSerializer_<S, T> = $IAttachmentSerializer$$Type<(S), (T)>;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDeathEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingDeathEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageSource$$Type)

public "getSource"(): $DamageSource
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "source"(): $DamageSource
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDeathEvent$$Type = ($LivingDeathEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDeathEvent_ = $LivingDeathEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.locating.ModFileDiscoveryAttributes" {
import {$IDependencyLocator, $IDependencyLocator$$Type} from "net.neoforged.neoforgespi.locating.IDependencyLocator"
import {$IModFileCandidateLocator, $IModFileCandidateLocator$$Type} from "net.neoforged.neoforgespi.locating.IModFileCandidateLocator"
import {$IModFile, $IModFile$$Type} from "net.neoforged.neoforgespi.locating.IModFile"
import {$IModFileReader, $IModFileReader$$Type} from "net.neoforged.neoforgespi.locating.IModFileReader"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModFileDiscoveryAttributes extends $Record {
static readonly "DEFAULT": $ModFileDiscoveryAttributes

constructor(parent: $IModFile$$Type, reader: $IModFileReader$$Type, locator: $IModFileCandidateLocator$$Type, dependencyLocator: $IDependencyLocator$$Type)

public "parent"(): $IModFile
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "merge"(arg0: $ModFileDiscoveryAttributes$$Type): $ModFileDiscoveryAttributes
public "reader"(): $IModFileReader
public "withLocator"(arg0: $IModFileCandidateLocator$$Type): $ModFileDiscoveryAttributes
public "dependencyLocator"(): $IDependencyLocator
public "locator"(): $IModFileCandidateLocator
public "withDependencyLocator"(arg0: $IDependencyLocator$$Type): $ModFileDiscoveryAttributes
public "withReader"(arg0: $IModFileReader$$Type): $ModFileDiscoveryAttributes
public "withParent"(arg0: $IModFile$$Type): $ModFileDiscoveryAttributes
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFileDiscoveryAttributes$$Type = ({"locator"?: $IModFileCandidateLocator$$Type, "reader"?: $IModFileReader$$Type, "dependencyLocator"?: $IDependencyLocator$$Type, "parent"?: $IModFile$$Type}) | ([locator?: $IModFileCandidateLocator$$Type, reader?: $IModFileReader$$Type, dependencyLocator?: $IDependencyLocator$$Type, parent?: $IModFile$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFileDiscoveryAttributes_ = $ModFileDiscoveryAttributes$$Type;
}}
declare module "net.neoforged.neoforge.common.world.BiomeGenerationSettingsBuilder" {
import {$GenerationStep$Decoration, $GenerationStep$Decoration$$Type} from "net.minecraft.world.level.levelgen.GenerationStep$Decoration"
import {$GenerationStep$Carving, $GenerationStep$Carving$$Type} from "net.minecraft.world.level.levelgen.GenerationStep$Carving"
import {$PlacedFeature, $PlacedFeature$$Type} from "net.minecraft.world.level.levelgen.placement.PlacedFeature"
import {$BiomeGenerationSettings$PlainBuilder, $BiomeGenerationSettings$PlainBuilder$$Type} from "net.minecraft.world.level.biome.BiomeGenerationSettings$PlainBuilder"
import {$List, $List$$Type} from "java.util.List"
import {$BiomeGenerationSettings, $BiomeGenerationSettings$$Type} from "net.minecraft.world.level.biome.BiomeGenerationSettings"
import {$ConfiguredWorldCarver, $ConfiguredWorldCarver$$Type} from "net.minecraft.world.level.levelgen.carver.ConfiguredWorldCarver"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $BiomeGenerationSettingsBuilder extends $BiomeGenerationSettings$PlainBuilder {

constructor(arg0: $BiomeGenerationSettings$$Type)

public "getFeatures"(arg0: $GenerationStep$Decoration$$Type): $List<($Holder<($PlacedFeature)>)>
public "getCarvers"(arg0: $GenerationStep$Carving$$Type): $List<($Holder<($ConfiguredWorldCarver<(any)>)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BiomeGenerationSettingsBuilder$$Type = ($BiomeGenerationSettingsBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BiomeGenerationSettingsBuilder_ = $BiomeGenerationSettingsBuilder$$Type;
}}
declare module "net.neoforged.fml.LogicalSide" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $LogicalSide extends $Enum<($LogicalSide)> {
static readonly "SERVER": $LogicalSide
static readonly "CLIENT": $LogicalSide


public static "values"(): ($LogicalSide)[]
public static "valueOf"(arg0: string): $LogicalSide
public "isClient"(): boolean
public "isServer"(): boolean
get "client"(): boolean
get "server"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LogicalSide$$Type = (("client") | ("server"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LogicalSide_ = $LogicalSide$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterClientTooltipComponentFactoriesEvent" {
import {$TooltipComponent, $TooltipComponent$$Type} from "net.minecraft.world.inventory.tooltip.TooltipComponent"
import {$Map, $Map$$Type} from "java.util.Map"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$ClientTooltipComponent, $ClientTooltipComponent$$Type} from "net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent"

export class $RegisterClientTooltipComponentFactoriesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($Class$$Type<($TooltipComponent$$Type)>), ($Function$$Type<($TooltipComponent$$Type), ($ClientTooltipComponent$$Type)>)>)

public "register"<T extends $TooltipComponent>(arg0: $Class$$Type<(T)>, arg1: $Function$$Type<(T), ($ClientTooltipComponent$$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterClientTooltipComponentFactoriesEvent$$Type = ($RegisterClientTooltipComponentFactoriesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterClientTooltipComponentFactoriesEvent_ = $RegisterClientTooltipComponentFactoriesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderHighlightEvent$Entity" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$EntityHitResult, $EntityHitResult$$Type} from "net.minecraft.world.phys.EntityHitResult"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$RenderHighlightEvent, $RenderHighlightEvent$$Type} from "net.neoforged.neoforge.client.event.RenderHighlightEvent"
import {$LevelRenderer, $LevelRenderer$$Type} from "net.minecraft.client.renderer.LevelRenderer"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"

export class $RenderHighlightEvent$Entity extends $RenderHighlightEvent {

constructor(arg0: $LevelRenderer$$Type, arg1: $Camera$$Type, arg2: $EntityHitResult$$Type, arg3: $DeltaTracker$$Type, arg4: $PoseStack$$Type, arg5: $MultiBufferSource$$Type)

public "getTarget"(): $EntityHitResult
get "target"(): $EntityHitResult
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderHighlightEvent$Entity$$Type = ($RenderHighlightEvent$Entity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderHighlightEvent$Entity_ = $RenderHighlightEvent$Entity$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Expired" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$MobEffectEvent, $MobEffectEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobEffectEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $MobEffectEvent$Expired extends $MobEffectEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $MobEffectInstance$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$Expired$$Type = ($MobEffectEvent$Expired);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent$Expired_ = $MobEffectEvent$Expired$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyReleased" {
import {$ScreenEvent$KeyInput, $ScreenEvent$KeyInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyInput"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$KeyReleased extends $ScreenEvent$KeyInput {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyReleased$$Type = ($ScreenEvent$KeyReleased);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyReleased_ = $ScreenEvent$KeyReleased$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ClimateSettingsBuilder" {
import {$Biome$ClimateSettings, $Biome$ClimateSettings$$Type} from "net.minecraft.world.level.biome.Biome$ClimateSettings"
import {$Biome$TemperatureModifier, $Biome$TemperatureModifier$$Type} from "net.minecraft.world.level.biome.Biome$TemperatureModifier"

export class $ClimateSettingsBuilder {


public static "copyOf"(arg0: $Biome$ClimateSettings$$Type): $ClimateSettingsBuilder
public static "create"(arg0: boolean, arg1: float, arg2: $Biome$TemperatureModifier$$Type, arg3: float): $ClimateSettingsBuilder
public "build"(): $Biome$ClimateSettings
public "setDownfall"(arg0: float): void
public "setTemperature"(arg0: float): void
public "getDownfall"(): float
public "hasPrecipitation"(): boolean
public "getTemperature"(): float
public "getTemperatureModifier"(): $Biome$TemperatureModifier
public "setTemperatureModifier"(arg0: $Biome$TemperatureModifier$$Type): void
public "setHasPrecipitation"(arg0: boolean): void
set "downfall"(value: float)
set "temperature"(value: float)
get "downfall"(): float
get "temperature"(): float
get "temperatureModifier"(): $Biome$TemperatureModifier
set "temperatureModifier"(value: $Biome$TemperatureModifier$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClimateSettingsBuilder$$Type = ($ClimateSettingsBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClimateSettingsBuilder_ = $ClimateSettingsBuilder$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IBakedModelExtension" {
import {$TextureAtlasSprite, $TextureAtlasSprite$$Type} from "net.minecraft.client.renderer.texture.TextureAtlasSprite"
import {$ItemDisplayContext, $ItemDisplayContext$$Type} from "net.minecraft.world.item.ItemDisplayContext"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$List, $List$$Type} from "java.util.List"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$BakedQuad, $BakedQuad$$Type} from "net.minecraft.client.renderer.block.model.BakedQuad"
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$ChunkRenderTypeSet, $ChunkRenderTypeSet$$Type} from "net.neoforged.neoforge.client.ChunkRenderTypeSet"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$ModelData, $ModelData$$Type} from "net.neoforged.neoforge.client.model.data.ModelData"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"

export interface $IBakedModelExtension {

 "useAmbientOcclusion"(arg0: $BlockState$$Type, arg1: $ModelData$$Type, arg2: $RenderType$$Type): $TriState
 "getQuads"(arg0: $BlockState$$Type, arg1: $Direction$$Type, arg2: $RandomSource$$Type, arg3: $ModelData$$Type, arg4: $RenderType$$Type): $List<($BakedQuad)>
 "getModelData"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $ModelData$$Type): $ModelData
 "getRenderTypes"(arg0: $BlockState$$Type, arg1: $RandomSource$$Type, arg2: $ModelData$$Type): $ChunkRenderTypeSet
 "getRenderTypes"(arg0: $ItemStack$$Type, arg1: boolean): $List<($RenderType)>
 "getRenderPasses"(arg0: $ItemStack$$Type, arg1: boolean): $List<($BakedModel)>
 "getParticleIcon"(arg0: $ModelData$$Type): $TextureAtlasSprite
 "applyTransform"(arg0: $ItemDisplayContext$$Type, arg1: $PoseStack$$Type, arg2: boolean): $BakedModel
}

export namespace $IBakedModelExtension {
const probejs$$marker: never
}
export class $IBakedModelExtension$$Static implements $IBakedModelExtension {


 "useAmbientOcclusion"(arg0: $BlockState$$Type, arg1: $ModelData$$Type, arg2: $RenderType$$Type): $TriState
 "getQuads"(arg0: $BlockState$$Type, arg1: $Direction$$Type, arg2: $RandomSource$$Type, arg3: $ModelData$$Type, arg4: $RenderType$$Type): $List<($BakedQuad)>
 "getModelData"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $ModelData$$Type): $ModelData
 "getRenderTypes"(arg0: $BlockState$$Type, arg1: $RandomSource$$Type, arg2: $ModelData$$Type): $ChunkRenderTypeSet
 "getRenderTypes"(arg0: $ItemStack$$Type, arg1: boolean): $List<($RenderType)>
 "getRenderPasses"(arg0: $ItemStack$$Type, arg1: boolean): $List<($BakedModel)>
 "getParticleIcon"(arg0: $ModelData$$Type): $TextureAtlasSprite
 "applyTransform"(arg0: $ItemDisplayContext$$Type, arg1: $PoseStack$$Type, arg2: boolean): $BakedModel
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBakedModelExtension$$Type = ($IBakedModelExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBakedModelExtension_ = $IBakedModelExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Closing" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$Closing extends $ScreenEvent {

constructor(arg0: $Screen$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Closing$$Type = ($ScreenEvent$Closing);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Closing_ = $ScreenEvent$Closing$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientChatReceivedEvent" {
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ChatType$Bound, $ChatType$Bound$$Type} from "net.minecraft.network.chat.ChatType$Bound"

export class $ClientChatReceivedEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ChatType$Bound$$Type, arg1: $Component$$Type, arg2: $UUID$$Type)

public "getMessage"(): $Component
public "isSystem"(): boolean
public "setMessage"(arg0: $Component$$Type): void
public "getBoundChatType"(): $ChatType$Bound
public "getSender"(): $UUID
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "message"(): $Component
get "system"(): boolean
set "message"(value: $Component$$Type)
get "boundChatType"(): $ChatType$Bound
get "sender"(): $UUID
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientChatReceivedEvent$$Type = ($ClientChatReceivedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientChatReceivedEvent_ = $ClientChatReceivedEvent$$Type;
}}
declare module "net.neoforged.neoforge.fluids.RegisterCauldronFluidContentEvent" {
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$IntegerProperty, $IntegerProperty$$Type} from "net.minecraft.world.level.block.state.properties.IntegerProperty"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterCauldronFluidContentEvent extends $Event implements $IModBusEvent {


public "register"(arg0: $Block$$Type, arg1: $Fluid$$Type, arg2: integer, arg3: $IntegerProperty$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterCauldronFluidContentEvent$$Type = ($RegisterCauldronFluidContentEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterCauldronFluidContentEvent_ = $RegisterCauldronFluidContentEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.PlaySoundSourceEvent" {
import {$SoundEngine, $SoundEngine$$Type} from "net.minecraft.client.sounds.SoundEngine"
import {$SoundInstance, $SoundInstance$$Type} from "net.minecraft.client.resources.sounds.SoundInstance"
import {$Channel, $Channel$$Type} from "com.mojang.blaze3d.audio.Channel"
import {$SoundEvent$SoundSourceEvent, $SoundEvent$SoundSourceEvent$$Type} from "net.neoforged.neoforge.client.event.sound.SoundEvent$SoundSourceEvent"

export class $PlaySoundSourceEvent extends $SoundEvent$SoundSourceEvent {

constructor(arg0: $SoundEngine$$Type, arg1: $SoundInstance$$Type, arg2: $Channel$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlaySoundSourceEvent$$Type = ($PlaySoundSourceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlaySoundSourceEvent_ = $PlaySoundSourceEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.NoteBlockEvent$Change" {
import {$NoteBlockEvent$Note, $NoteBlockEvent$Note$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent$Note"
import {$NoteBlockEvent, $NoteBlockEvent$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$NoteBlockEvent$Octave, $NoteBlockEvent$Octave$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent$Octave"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $NoteBlockEvent$Change extends $NoteBlockEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: integer, arg4: integer)

public "getOldOctave"(): $NoteBlockEvent$Octave
public "getOldNote"(): $NoteBlockEvent$Note
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "oldOctave"(): $NoteBlockEvent$Octave
get "oldNote"(): $NoteBlockEvent$Note
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NoteBlockEvent$Change$$Type = ($NoteBlockEvent$Change);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NoteBlockEvent$Change_ = $NoteBlockEvent$Change$$Type;
}}
declare module "net.neoforged.neoforge.registries.holdersets.HolderSetType" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ICustomHolderSet, $ICustomHolderSet$$Type} from "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $HolderSetType {

 "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
 "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeHolderSetType
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeHolderSetTypeTag
}

export namespace $HolderSetType {
const probejs$$marker: never
}
export class $HolderSetType$$Static implements $HolderSetType {


 "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
 "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $HolderSetType$$Type = (Special.NeoforgeHolderSetType);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $HolderSetType_ = $HolderSetType$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.item.ItemEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"

export class $ItemEvent extends $EntityEvent {

constructor(arg0: $ItemEntity$$Type)

public "getEntity"(): $ItemEntity
get "entity"(): $ItemEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemEvent$$Type = ($ItemEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemEvent_ = $ItemEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterClientCommandsEvent" {
import {$CommandBuildContext, $CommandBuildContext$$Type} from "net.minecraft.commands.CommandBuildContext"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$CommandDispatcher, $CommandDispatcher$$Type} from "com.mojang.brigadier.CommandDispatcher"
import {$CommandSourceStack, $CommandSourceStack$$Type} from "net.minecraft.commands.CommandSourceStack"

export class $RegisterClientCommandsEvent extends $Event {

constructor(arg0: $CommandDispatcher$$Type<($CommandSourceStack$$Type)>, arg1: $CommandBuildContext$$Type)

public "getDispatcher"(): $CommandDispatcher<($CommandSourceStack)>
public "getBuildContext"(): $CommandBuildContext
get "dispatcher"(): $CommandDispatcher<($CommandSourceStack)>
get "buildContext"(): $CommandBuildContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterClientCommandsEvent$$Type = ($RegisterClientCommandsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterClientCommandsEvent_ = $RegisterClientCommandsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerXpEvent$LevelChange" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerXpEvent, $PlayerXpEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerXpEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerXpEvent$LevelChange extends $PlayerXpEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: integer)

public "setLevels"(arg0: integer): void
public "getLevels"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
set "levels"(value: integer)
get "levels"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerXpEvent$LevelChange$$Type = ($PlayerXpEvent$LevelChange);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerXpEvent$LevelChange_ = $PlayerXpEvent$LevelChange$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IFluidStateExtension" {
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$Boat, $Boat$$Type} from "net.minecraft.world.entity.vehicle.Boat"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IFluidStateExtension {

 "move"(arg0: $LivingEntity$$Type, arg1: $Vec3$$Type, arg2: double): boolean
 "getExplosionResistance"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): float
 "getAdjacentBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: $PathType$$Type): $PathType
 "canExtinguish"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "canConvertToSource"(arg0: $Level$$Type, arg1: $BlockPos$$Type): boolean
 "supportsBoating"(arg0: $Boat$$Type): boolean
 "getFluidType"(): $FluidType
 "getBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: boolean): $PathType
 "canHydrate"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockPos$$Type): boolean
get "fluidType"(): $FluidType
}

export namespace $IFluidStateExtension {
const probejs$$marker: never
}
export class $IFluidStateExtension$$Static implements $IFluidStateExtension {


 "move"(arg0: $LivingEntity$$Type, arg1: $Vec3$$Type, arg2: double): boolean
 "getExplosionResistance"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): float
 "getAdjacentBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: $PathType$$Type): $PathType
 "canExtinguish"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "canConvertToSource"(arg0: $Level$$Type, arg1: $BlockPos$$Type): boolean
 "supportsBoating"(arg0: $Boat$$Type): boolean
 "getFluidType"(): $FluidType
 "getBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: boolean): $PathType
 "canHydrate"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockPos$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IFluidStateExtension$$Type = ($IFluidStateExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IFluidStateExtension_ = $IFluidStateExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$FluidPlaceBlockEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$FluidPlaceBlockEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type)

public "getOriginalState"(): $BlockState
public "getNewState"(): $BlockState
public "getLiquidPos"(): $BlockPos
public "setNewState"(arg0: $BlockState$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "originalState"(): $BlockState
get "newState"(): $BlockState
get "liquidPos"(): $BlockPos
set "newState"(value: $BlockState$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$FluidPlaceBlockEvent$$Type = ($BlockEvent$FluidPlaceBlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$FluidPlaceBlockEvent_ = $BlockEvent$FluidPlaceBlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.LevelTickEvent$Pre" {
import {$LevelTickEvent, $LevelTickEvent$$Type} from "net.neoforged.neoforge.event.tick.LevelTickEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BooleanSupplier, $BooleanSupplier$$Type} from "java.util.function.BooleanSupplier"

export class $LevelTickEvent$Pre extends $LevelTickEvent {

constructor(arg0: $BooleanSupplier$$Type, arg1: $Level$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelTickEvent$Pre$$Type = ($LevelTickEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelTickEvent$Pre_ = $LevelTickEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IFontExtension" {
import {$FormattedText, $FormattedText$$Type} from "net.minecraft.network.chat.FormattedText"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"

export interface $IFontExtension {

 "self"(): $Font
 "ellipsize"(arg0: $FormattedText$$Type, arg1: integer): $FormattedText

(): $Font$$Type
}

export namespace $IFontExtension {
const ELLIPSIS: $FormattedText
const probejs$$marker: never
}
export class $IFontExtension$$Static implements $IFontExtension {
static readonly "ELLIPSIS": $FormattedText


 "self"(): $Font
 "ellipsize"(arg0: $FormattedText$$Type, arg1: integer): $FormattedText
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IFontExtension$$Type = (() => $Font$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IFontExtension_ = $IFontExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingChangeTargetEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingChangeTargetEvent$ILivingTargetType, $LivingChangeTargetEvent$ILivingTargetType$$Type} from "net.neoforged.neoforge.event.entity.living.LivingChangeTargetEvent$ILivingTargetType"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingChangeTargetEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $LivingEntity$$Type, arg2: $LivingChangeTargetEvent$ILivingTargetType$$Type)

public "getOriginalAboutToBeSetTarget"(): $LivingEntity
public "getTargetType"(): $LivingChangeTargetEvent$ILivingTargetType
public "getNewAboutToBeSetTarget"(): $LivingEntity
public "setNewAboutToBeSetTarget"(arg0: $LivingEntity$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "originalAboutToBeSetTarget"(): $LivingEntity
get "targetType"(): $LivingChangeTargetEvent$ILivingTargetType
get "newAboutToBeSetTarget"(): $LivingEntity
set "newAboutToBeSetTarget"(value: $LivingEntity$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingChangeTargetEvent$$Type = ($LivingChangeTargetEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingChangeTargetEvent_ = $LivingChangeTargetEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterShadersEvent" {
import {$ResourceProvider, $ResourceProvider$$Type} from "net.minecraft.server.packs.resources.ResourceProvider"
import {$Pair, $Pair$$Type} from "com.mojang.datafixers.util.Pair"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ShaderInstance, $ShaderInstance$$Type} from "net.minecraft.client.renderer.ShaderInstance"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $RegisterShadersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ResourceProvider$$Type, arg1: $List$$Type<($Pair$$Type<($ShaderInstance$$Type), ($Consumer$$Type<($ShaderInstance$$Type)>)>)>)

public "registerShader"(arg0: $ShaderInstance$$Type, arg1: $Consumer$$Type<($ShaderInstance)>): void
public "getResourceProvider"(): $ResourceProvider
get "resourceProvider"(): $ResourceProvider
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterShadersEvent$$Type = ($RegisterShadersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterShadersEvent_ = $RegisterShadersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityAttributeModificationEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Attribute, $Attribute$$Type} from "net.minecraft.world.entity.ai.attributes.Attribute"
import {$AttributeSupplier$Builder, $AttributeSupplier$Builder$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeSupplier$Builder"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $EntityAttributeModificationEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($EntityType$$Type<($LivingEntity$$Type)>), ($AttributeSupplier$Builder$$Type)>)

public "add"(arg0: $EntityType$$Type<($LivingEntity$$Type)>, arg1: $Holder$$Type<($Attribute)>): void
public "add"(arg0: $EntityType$$Type<($LivingEntity$$Type)>, arg1: $Holder$$Type<($Attribute)>, arg2: double): void
public "has"(arg0: $EntityType$$Type<($LivingEntity$$Type)>, arg1: $Holder$$Type<($Attribute)>): boolean
public "getTypes"(): $List<($EntityType<($LivingEntity)>)>
get "types"(): $List<($EntityType<($LivingEntity)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityAttributeModificationEvent$$Type = ($EntityAttributeModificationEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityAttributeModificationEvent_ = $EntityAttributeModificationEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderPlayerEvent" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$PlayerRenderer, $PlayerRenderer$$Type} from "net.minecraft.client.renderer.entity.player.PlayerRenderer"

export class $RenderPlayerEvent extends $PlayerEvent {


public "getPackedLight"(): integer
public "getRenderer"(): $PlayerRenderer
public "getPoseStack"(): $PoseStack
public "getPartialTick"(): float
public "getMultiBufferSource"(): $MultiBufferSource
public "getEntity"(): $Entity
get "packedLight"(): integer
get "renderer"(): $PlayerRenderer
get "poseStack"(): $PoseStack
get "partialTick"(): float
get "multiBufferSource"(): $MultiBufferSource
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderPlayerEvent$$Type = ($RenderPlayerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderPlayerEvent_ = $RenderPlayerEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPlayerNetworkEvent" {
import {$MultiPlayerGameMode, $MultiPlayerGameMode$$Type} from "net.minecraft.client.multiplayer.MultiPlayerGameMode"
import {$LocalPlayer, $LocalPlayer$$Type} from "net.minecraft.client.player.LocalPlayer"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export class $ClientPlayerNetworkEvent extends $Event {


public "getConnection"(): $Connection
public "getMultiPlayerGameMode"(): $MultiPlayerGameMode
public "getPlayer"(): $LocalPlayer
get "connection"(): $Connection
get "multiPlayerGameMode"(): $MultiPlayerGameMode
get "player"(): $LocalPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPlayerNetworkEvent$$Type = ($ClientPlayerNetworkEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPlayerNetworkEvent_ = $ClientPlayerNetworkEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.DataPackRegistryEvent$NewRegistry" {
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryBuilder, $RegistryBuilder$$Type} from "net.neoforged.neoforge.registries.RegistryBuilder"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$DataPackRegistryEvent, $DataPackRegistryEvent$$Type} from "net.neoforged.neoforge.registries.DataPackRegistryEvent"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $DataPackRegistryEvent$NewRegistry extends $DataPackRegistryEvent {

constructor()

public "dataPackRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<(T)>): void
public "dataPackRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<(T)>, arg2: $Codec$$Type<(T)>, arg3: $Consumer$$Type<($RegistryBuilder<(T)>)>): void
public "dataPackRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<(T)>, arg2: $Codec$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataPackRegistryEvent$NewRegistry$$Type = ($DataPackRegistryEvent$NewRegistry);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataPackRegistryEvent$NewRegistry_ = $DataPackRegistryEvent$NewRegistry$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerXpEvent$XpChange" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerXpEvent, $PlayerXpEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerXpEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerXpEvent$XpChange extends $PlayerXpEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: integer)

public "getAmount"(): integer
public "setAmount"(arg0: integer): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "amount"(): integer
set "amount"(value: integer)
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerXpEvent$XpChange$$Type = ($PlayerXpEvent$XpChange);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerXpEvent$XpChange_ = $PlayerXpEvent$XpChange$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.nodes.PermissionNode$PermissionResolver" {
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$PermissionDynamicContext, $PermissionDynamicContext$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContext"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export interface $PermissionNode$PermissionResolver<T> {

 "resolve"(arg0: $ServerPlayer$$Type, arg1: $UUID$$Type, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T

(arg0: $ServerPlayer, arg1: $UUID, ...arg2: ($PermissionDynamicContext<(any)>)[]): T
}

export namespace $PermissionNode$PermissionResolver {
const probejs$$marker: never
}
export class $PermissionNode$PermissionResolver$$Static<T> implements $PermissionNode$PermissionResolver {


 "resolve"(arg0: $ServerPlayer$$Type, arg1: $UUID$$Type, ...arg2: ($PermissionDynamicContext$$Type<(any)>)[]): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionNode$PermissionResolver$$Type<T> = ((arg0: $ServerPlayer, arg1: $UUID, arg2: ($PermissionDynamicContext<(any)>)[]) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionNode$PermissionResolver_<T> = $PermissionNode$PermissionResolver$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent extends $LivingEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$$Type = ($PlayerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent_ = $PlayerEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkWatchEvent$UnWatch" {
import {$ChunkWatchEvent, $ChunkWatchEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkWatchEvent"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$ChunkPos, $ChunkPos$$Type} from "net.minecraft.world.level.ChunkPos"

export class $ChunkWatchEvent$UnWatch extends $ChunkWatchEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $ChunkPos$$Type, arg2: $ServerLevel$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkWatchEvent$UnWatch$$Type = ($ChunkWatchEvent$UnWatch);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkWatchEvent$UnWatch_ = $ChunkWatchEvent$UnWatch$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.RegisterCapabilitiesEvent" {
import {$BlockCapability, $BlockCapability$$Type} from "net.neoforged.neoforge.capabilities.BlockCapability"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$EntityCapability, $EntityCapability$$Type} from "net.neoforged.neoforge.capabilities.EntityCapability"
import {$BlockEntityType, $BlockEntityType$$Type} from "net.minecraft.world.level.block.entity.BlockEntityType"
import {$ICapabilityProvider, $ICapabilityProvider$$Type} from "net.neoforged.neoforge.capabilities.ICapabilityProvider"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$ItemCapability, $ItemCapability$$Type} from "net.neoforged.neoforge.capabilities.ItemCapability"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$IBlockCapabilityProvider, $IBlockCapabilityProvider$$Type} from "net.neoforged.neoforge.capabilities.IBlockCapabilityProvider"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $RegisterCapabilitiesEvent extends $Event implements $IModBusEvent {


public "registerEntity"<T, C, E extends $Entity>(arg0: $EntityCapability$$Type<(T), (C)>, arg1: $EntityType$$Type<(E)>, arg2: $ICapabilityProvider$$Type<(E), (C), (T)>): void
public "isEntityRegistered"(arg0: $EntityCapability$$Type<(any), (any)>, arg1: $EntityType$$Type<(any)>): boolean
public "isItemRegistered"(arg0: $ItemCapability$$Type<(any), (any)>, arg1: $Item$$Type): boolean
public "isBlockRegistered"(arg0: $BlockCapability$$Type<(any), (any)>, arg1: $Block$$Type): boolean
public "registerBlock"<T, C>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $IBlockCapabilityProvider$$Type<(T), (C)>, ...arg2: ($Block$$Type)[]): void
public "registerItem"<T, C>(arg0: $ItemCapability$$Type<(T), (C)>, arg1: $ICapabilityProvider$$Type<($ItemStack), (C), (T)>, ...arg2: ($ItemLike$$Type)[]): void
public "registerBlockEntity"<T, C, BE extends $BlockEntity>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $BlockEntityType$$Type<(BE)>, arg2: $ICapabilityProvider$$Type<(BE), (C), (T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterCapabilitiesEvent$$Type = ($RegisterCapabilitiesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterCapabilitiesEvent_ = $RegisterCapabilitiesEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.language.ModFileScanData$AnnotationData" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Type, $Type$$Type} from "org.objectweb.asm.Type"
import {$ElementType, $ElementType$$Type} from "java.lang.annotation.ElementType"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModFileScanData$AnnotationData extends $Record {

constructor(annotationType: $Type$$Type, targetType: $ElementType$$Type, clazz: $Type$$Type, memberName: string, annotationData: $Map$$Type<(string), (any)>)

public "clazz"(): $Type
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "annotationData"(): $Map<(string), (any)>
public "annotationType"(): $Type
public "targetType"(): $ElementType
public "memberName"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFileScanData$AnnotationData$$Type = ({"clazz"?: $Type$$Type, "memberName"?: string, "targetType"?: $ElementType$$Type, "annotationType"?: $Type$$Type, "annotationData"?: $Map$$Type<(string), (any)>}) | ([clazz?: $Type$$Type, memberName?: string, targetType?: $ElementType$$Type, annotationType?: $Type$$Type, annotationData?: $Map$$Type<(string), (any)>]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFileScanData$AnnotationData_ = $ModFileScanData$AnnotationData$$Type;
}}
declare module "net.neoforged.neoforge.common.conditions.ICondition$IContext" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $ICondition$IContext {

 "getTag"<T>(arg0: $TagKey$$Type<(T)>): $Collection<($Holder<(T)>)>
 "getAllTags"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $Map<($ResourceLocation), ($Collection<($Holder<(T)>)>)>

(arg0: $ResourceKey<($Registry<(T)>)>): $Map$$Type<($ResourceLocation$$Type), ($Collection$$Type<($Holder$$Type<(T)>)>)>
}

export namespace $ICondition$IContext {
const TAGS_INVALID: $ICondition$IContext
const EMPTY: $ICondition$IContext
const probejs$$marker: never
}
export class $ICondition$IContext$$Static implements $ICondition$IContext {
static readonly "TAGS_INVALID": $ICondition$IContext
static readonly "EMPTY": $ICondition$IContext


 "getTag"<T>(arg0: $TagKey$$Type<(T)>): $Collection<($Holder<(T)>)>
 "getAllTags"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $Map<($ResourceLocation), ($Collection<($Holder<(T)>)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICondition$IContext$$Type = ((arg0: $ResourceKey<($Registry<(T)>)>) => $Map$$Type<($ResourceLocation$$Type), ($Collection$$Type<($Holder$$Type<(T)>)>)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICondition$IContext_ = $ICondition$IContext$$Type;
}}
declare module "net.neoforged.neoforge.event.level.AlterGroundEvent$StateProvider" {
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $AlterGroundEvent$StateProvider {

 "getState"(arg0: $RandomSource$$Type, arg1: $BlockPos$$Type): $BlockState

(arg0: $RandomSource, arg1: $BlockPos): $BlockState$$Type
}

export namespace $AlterGroundEvent$StateProvider {
const probejs$$marker: never
}
export class $AlterGroundEvent$StateProvider$$Static implements $AlterGroundEvent$StateProvider {


 "getState"(arg0: $RandomSource$$Type, arg1: $BlockPos$$Type): $BlockState
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AlterGroundEvent$StateProvider$$Type = ((arg0: $RandomSource, arg1: $BlockPos) => $BlockState$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AlterGroundEvent$StateProvider_ = $AlterGroundEvent$StateProvider$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Applicable" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$MobEffectEvent, $MobEffectEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobEffectEvent"
import {$MobEffectEvent$Applicable$Result, $MobEffectEvent$Applicable$Result$$Type} from "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Applicable$Result"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $MobEffectEvent$Applicable extends $MobEffectEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $MobEffectInstance$$Type)

public "setResult"(arg0: $MobEffectEvent$Applicable$Result$$Type): void
public "getResult"(): $MobEffectEvent$Applicable$Result
public "getEffectInstance"(): $MobEffectInstance
public "getApplicationResult"(): boolean
set "result"(value: $MobEffectEvent$Applicable$Result$$Type)
get "result"(): $MobEffectEvent$Applicable$Result
get "effectInstance"(): $MobEffectInstance
get "applicationResult"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$Applicable$$Type = ($MobEffectEvent$Applicable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent$Applicable_ = $MobEffectEvent$Applicable$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkDataEvent$Save" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$ChunkDataEvent, $ChunkDataEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkDataEvent"
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $ChunkDataEvent$Save extends $ChunkDataEvent {

constructor(arg0: $ChunkAccess$$Type, arg1: $LevelAccessor$$Type, arg2: $CompoundTag$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkDataEvent$Save$$Type = ($ChunkDataEvent$Save);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkDataEvent$Save_ = $ChunkDataEvent$Save$$Type;
}}
declare module "net.neoforged.neoforge.event.GrindstoneEvent$OnPlaceItem" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$GrindstoneEvent, $GrindstoneEvent$$Type} from "net.neoforged.neoforge.event.GrindstoneEvent"

export class $GrindstoneEvent$OnPlaceItem extends $GrindstoneEvent implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: integer)

public "getOutput"(): $ItemStack
public "setOutput"(arg0: $ItemStack$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "output"(): $ItemStack
set "output"(value: $ItemStack$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GrindstoneEvent$OnPlaceItem$$Type = ($GrindstoneEvent$OnPlaceItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GrindstoneEvent$OnPlaceItem_ = $GrindstoneEvent$OnPlaceItem$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockDropsEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockDropsEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $ServerLevel$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: $List$$Type<($ItemEntity$$Type)>, arg5: $Entity$$Type, arg6: $ItemStack$$Type)

public "getLevel"(): $ServerLevel
public "setCanceled"(arg0: boolean): void
public "getBlockEntity"(): $BlockEntity
public "getDroppedExperience"(): integer
public "getTool"(): $ItemStack
public "getBreaker"(): $Entity
public "getDrops"(): $List<($ItemEntity)>
public "setDroppedExperience"(arg0: integer): void
public "isCanceled"(): boolean
get "level"(): $ServerLevel
set "canceled"(value: boolean)
get "blockEntity"(): $BlockEntity
get "droppedExperience"(): integer
get "tool"(): $ItemStack
get "breaker"(): $Entity
get "drops"(): $List<($ItemEntity)>
set "droppedExperience"(value: integer)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockDropsEvent$$Type = ($BlockDropsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockDropsEvent_ = $BlockDropsEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableStructureInfo$StructureInfo$Builder" {
import {$ModifiableStructureInfo$StructureInfo, $ModifiableStructureInfo$StructureInfo$$Type} from "net.neoforged.neoforge.common.world.ModifiableStructureInfo$StructureInfo"
import {$StructureSettingsBuilder, $StructureSettingsBuilder$$Type} from "net.neoforged.neoforge.common.world.StructureSettingsBuilder"

export class $ModifiableStructureInfo$StructureInfo$Builder {


public static "copyOf"(arg0: $ModifiableStructureInfo$StructureInfo$$Type): $ModifiableStructureInfo$StructureInfo$Builder
public "build"(): $ModifiableStructureInfo$StructureInfo
public "getStructureSettings"(): $StructureSettingsBuilder
get "structureSettings"(): $StructureSettingsBuilder
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableStructureInfo$StructureInfo$Builder$$Type = ($ModifiableStructureInfo$StructureInfo$Builder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableStructureInfo$StructureInfo$Builder_ = $ModifiableStructureInfo$StructureInfo$Builder$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyReleased$Post" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ScreenEvent$KeyReleased, $ScreenEvent$KeyReleased$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyReleased"

export class $ScreenEvent$KeyReleased$Post extends $ScreenEvent$KeyReleased implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyReleased$Post$$Type = ($ScreenEvent$KeyReleased$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyReleased$Post_ = $ScreenEvent$KeyReleased$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.PlaySoundEvent" {
import {$SoundEvent, $SoundEvent$$Type} from "net.neoforged.neoforge.client.event.sound.SoundEvent"
import {$SoundEngine, $SoundEngine$$Type} from "net.minecraft.client.sounds.SoundEngine"
import {$SoundInstance, $SoundInstance$$Type} from "net.minecraft.client.resources.sounds.SoundInstance"

export class $PlaySoundEvent extends $SoundEvent {

constructor(arg0: $SoundEngine$$Type, arg1: $SoundInstance$$Type)

public "getName"(): string
public "getSound"(): $SoundInstance
public "getOriginalSound"(): $SoundInstance
public "setSound"(arg0: $SoundInstance$$Type): void
get "name"(): string
get "sound"(): $SoundInstance
get "originalSound"(): $SoundInstance
set "sound"(value: $SoundInstance$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlaySoundEvent$$Type = ($PlaySoundEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlaySoundEvent_ = $PlaySoundEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.SpawnClusterSizeEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $SpawnClusterSizeEvent extends $LivingEvent {

constructor(arg0: $Mob$$Type)

public "getSize"(): integer
public "setSize"(arg0: integer): void
public "getEntity"(): $Entity
get "size"(): integer
set "size"(value: integer)
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SpawnClusterSizeEvent$$Type = ($SpawnClusterSizeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SpawnClusterSizeEvent_ = $SpawnClusterSizeEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$NameFormat" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent$NameFormat extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Component$$Type)

public "getUsername"(): $Component
public "getEntity"(): $Entity
public "getDisplayname"(): $Component
public "setDisplayname"(arg0: $Component$$Type): void
get "username"(): $Component
get "entity"(): $Entity
get "displayname"(): $Component
set "displayname"(value: $Component$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$NameFormat$$Type = ($PlayerEvent$NameFormat);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$NameFormat_ = $PlayerEvent$NameFormat$$Type;
}}
declare module "net.neoforged.neoforge.event.level.PistonEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$PistonStructureResolver, $PistonStructureResolver$$Type} from "net.minecraft.world.level.block.piston.PistonStructureResolver"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$PistonEvent$PistonMoveType, $PistonEvent$PistonMoveType$$Type} from "net.neoforged.neoforge.event.level.PistonEvent$PistonMoveType"

export class $PistonEvent extends $BlockEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $PistonEvent$PistonMoveType$$Type)

public "getDirection"(): $Direction
public "getPistonMoveType"(): $PistonEvent$PistonMoveType
public "getFaceOffsetPos"(): $BlockPos
public "getStructureHelper"(): $PistonStructureResolver
get "direction"(): $Direction
get "pistonMoveType"(): $PistonEvent$PistonMoveType
get "faceOffsetPos"(): $BlockPos
get "structureHelper"(): $PistonStructureResolver
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PistonEvent$$Type = ($PistonEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PistonEvent_ = $PistonEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderBlockScreenEffectEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$RenderBlockScreenEffectEvent$OverlayType, $RenderBlockScreenEffectEvent$OverlayType$$Type} from "net.neoforged.neoforge.client.event.RenderBlockScreenEffectEvent$OverlayType"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $RenderBlockScreenEffectEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $PoseStack$$Type, arg2: $RenderBlockScreenEffectEvent$OverlayType$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type)

public "getOverlayType"(): $RenderBlockScreenEffectEvent$OverlayType
public "getBlockPos"(): $BlockPos
public "getBlockState"(): $BlockState
public "getPoseStack"(): $PoseStack
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "overlayType"(): $RenderBlockScreenEffectEvent$OverlayType
get "blockPos"(): $BlockPos
get "blockState"(): $BlockState
get "poseStack"(): $PoseStack
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderBlockScreenEffectEvent$$Type = ($RenderBlockScreenEffectEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderBlockScreenEffectEvent_ = $RenderBlockScreenEffectEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ICommonPacketListener" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$PacketListener, $PacketListener$$Type} from "net.minecraft.network.PacketListener"
import {$CrashReport, $CrashReport$$Type} from "net.minecraft.CrashReport"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$DisconnectionDetails, $DisconnectionDetails$$Type} from "net.minecraft.network.DisconnectionDetails"
import {$ConnectionType, $ConnectionType$$Type} from "net.neoforged.neoforge.network.connection.ConnectionType"
import {$Exception, $Exception$$Type} from "java.lang.Exception"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$ReentrantBlockableEventLoop, $ReentrantBlockableEventLoop$$Type} from "net.minecraft.util.thread.ReentrantBlockableEventLoop"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$CrashReportCategory, $CrashReportCategory$$Type} from "net.minecraft.CrashReportCategory"

export interface $ICommonPacketListener extends $PacketListener {

 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
get "connection"(): $Connection
get "connectionType"(): $ConnectionType
get "mainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
get "acceptingMessages"(): boolean
}

export namespace $ICommonPacketListener {
const probejs$$marker: never
}
export class $ICommonPacketListener$$Static implements $ICommonPacketListener {


 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICommonPacketListener$$Type = ($ICommonPacketListener);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICommonPacketListener_ = $ICommonPacketListener$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.RegisterSpawnPlacementsEvent$Operation" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $RegisterSpawnPlacementsEvent$Operation extends $Enum<($RegisterSpawnPlacementsEvent$Operation)> {
static readonly "OR": $RegisterSpawnPlacementsEvent$Operation
static readonly "AND": $RegisterSpawnPlacementsEvent$Operation
static readonly "REPLACE": $RegisterSpawnPlacementsEvent$Operation


public static "values"(): ($RegisterSpawnPlacementsEvent$Operation)[]
public static "valueOf"(arg0: string): $RegisterSpawnPlacementsEvent$Operation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterSpawnPlacementsEvent$Operation$$Type = (("and") | ("or") | ("replace"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterSpawnPlacementsEvent$Operation_ = $RegisterSpawnPlacementsEvent$Operation$$Type;
}}
declare module "net.neoforged.neoforge.network.registration.HandlerThread" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $HandlerThread extends $Enum<($HandlerThread)> {
static readonly "NETWORK": $HandlerThread
static readonly "MAIN": $HandlerThread


public static "values"(): ($HandlerThread)[]
public static "valueOf"(arg0: string): $HandlerThread
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $HandlerThread$$Type = (("main") | ("network"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $HandlerThread_ = $HandlerThread$$Type;
}}
declare module "net.neoforged.neoforge.client.gui.map.RegisterMapDecorationRenderersEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IMapDecorationRenderer, $IMapDecorationRenderer$$Type} from "net.neoforged.neoforge.client.gui.map.IMapDecorationRenderer"
import {$MapDecorationType, $MapDecorationType$$Type} from "net.minecraft.world.level.saveddata.maps.MapDecorationType"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterMapDecorationRenderersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($MapDecorationType$$Type), ($IMapDecorationRenderer$$Type)>)

public "register"(arg0: $MapDecorationType$$Type, arg1: $IMapDecorationRenderer$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterMapDecorationRenderersEvent$$Type = ($RegisterMapDecorationRenderersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterMapDecorationRenderersEvent_ = $RegisterMapDecorationRenderersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ExplosionKnockbackEvent" {
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$List, $List$$Type} from "java.util.List"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ExplosionEvent, $ExplosionEvent$$Type} from "net.neoforged.neoforge.event.level.ExplosionEvent"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $ExplosionKnockbackEvent extends $ExplosionEvent {

constructor(arg0: $Level$$Type, arg1: $Explosion$$Type, arg2: $Entity$$Type, arg3: $Vec3$$Type)

public "getAffectedEntity"(): $Entity
public "getAffectedBlocks"(): $List<($BlockPos)>
public "getKnockbackVelocity"(): $Vec3
public "setKnockbackVelocity"(arg0: $Vec3$$Type): void
get "affectedEntity"(): $Entity
get "affectedBlocks"(): $List<($BlockPos)>
get "knockbackVelocity"(): $Vec3
set "knockbackVelocity"(value: $Vec3$$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExplosionKnockbackEvent$$Type = ($ExplosionKnockbackEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExplosionKnockbackEvent_ = $ExplosionKnockbackEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.DataMapType$Builder" {
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$DataMapType, $DataMapType$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType"

export class $DataMapType$Builder<T, R> {


public "build"(): $DataMapType<(R), (T)>
public "synced"(arg0: $Codec$$Type<(T)>, arg1: boolean): $DataMapType$Builder<(T), (R)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataMapType$Builder$$Type<T, R> = ($DataMapType$Builder<(T), (R)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataMapType$Builder_<T, R> = $DataMapType$Builder$$Type<(T), (R)>;
}}
declare module "net.neoforged.neoforge.common.util.AttributeTooltipContext" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$MapId, $MapId$$Type} from "net.minecraft.world.level.saveddata.maps.MapId"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Item$TooltipContext, $Item$TooltipContext$$Type} from "net.minecraft.world.item.Item$TooltipContext"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$MapItemSavedData, $MapItemSavedData$$Type} from "net.minecraft.world.level.saveddata.maps.MapItemSavedData"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $AttributeTooltipContext extends $Item$TooltipContext {

 "flag"(): $TooltipFlag
 "player"(): $Player
 "level"(): $Level
 "tickRate"(): float
 "registries"(): $HolderLookup$Provider
 "mapData"(arg0: $MapId$$Type): $MapItemSavedData
}

export namespace $AttributeTooltipContext {
function of(arg0: $Player$$Type, arg1: $Item$TooltipContext$$Type, arg2: $TooltipFlag$$Type): $AttributeTooltipContext
function of(arg0: $Level$$Type): $Item$TooltipContext
function of(arg0: $HolderLookup$Provider$$Type): $Item$TooltipContext
const probejs$$marker: never
}
export class $AttributeTooltipContext$$Static implements $AttributeTooltipContext {


static "of"(arg0: $Player$$Type, arg1: $Item$TooltipContext$$Type, arg2: $TooltipFlag$$Type): $AttributeTooltipContext
 "flag"(): $TooltipFlag
 "player"(): $Player
static "of"(arg0: $Level$$Type): $Item$TooltipContext
static "of"(arg0: $HolderLookup$Provider$$Type): $Item$TooltipContext
 "level"(): $Level
 "tickRate"(): float
 "registries"(): $HolderLookup$Provider
 "mapData"(arg0: $MapId$$Type): $MapItemSavedData
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttributeTooltipContext$$Type = ($AttributeTooltipContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttributeTooltipContext_ = $AttributeTooltipContext$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityEvent extends $Event {

constructor(arg0: $Entity$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityEvent$$Type = ($EntityEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityEvent_ = $EntityEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEvent$LivingJumpEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $LivingEvent$LivingJumpEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEvent$LivingJumpEvent$$Type = ($LivingEvent$LivingJumpEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEvent$LivingJumpEvent_ = $LivingEvent$LivingJumpEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.IShearable" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$List, $List$$Type} from "java.util.List"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export interface $IShearable {

 "onSheared"(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Level$$Type, arg3: $BlockPos$$Type): $List<($ItemStack)>
 "isShearable"(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Level$$Type, arg3: $BlockPos$$Type): boolean
 "spawnShearedDrop"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $ItemStack$$Type): void
}

export namespace $IShearable {
const probejs$$marker: never
}
export class $IShearable$$Static implements $IShearable {


 "onSheared"(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Level$$Type, arg3: $BlockPos$$Type): $List<($ItemStack)>
 "isShearable"(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Level$$Type, arg3: $BlockPos$$Type): boolean
 "spawnShearedDrop"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $ItemStack$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IShearable$$Type = ($IShearable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IShearable_ = $IShearable$$Type;
}}
declare module "net.neoforged.neoforge.entity.PartEntity" {
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$ScoreHolder, $ScoreHolder$$Type} from "net.minecraft.world.scores.ScoreHolder"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$GameProfile, $GameProfile$$Type} from "com.mojang.authlib.GameProfile"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$PortalProcessor, $PortalProcessor$$Type} from "net.minecraft.world.entity.PortalProcessor"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$ServerEntity, $ServerEntity$$Type} from "net.minecraft.server.level.ServerEntity"
import {$ClientGamePacketListener, $ClientGamePacketListener$$Type} from "net.minecraft.network.protocol.game.ClientGamePacketListener"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export class $PartEntity<T extends $Entity> extends $Entity {
 "invulnerableTime": integer
static readonly "UUID_TAG": string
static readonly "BASE_TICKS_REQUIRED_TO_FREEZE": integer
 "fallDistance": float
 "hasImpulse": boolean
 "portalProcess": $PortalProcessor
 "verticalCollision": boolean
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_0_5": double
static readonly "MAX_ENTITY_TAG_COUNT": integer
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_0_2": float
 "verticalCollisionBelow": boolean
 "tickCount": integer
 "noPhysics": boolean
 "yo": double
 "yOld": double
static readonly "DEFAULT_BB_WIDTH": float
 "minorHorizontalCollision": boolean
static readonly "BOARDING_COOLDOWN": integer
static readonly "DEFAULT_BB_HEIGHT": float
 "yRotO": float
static readonly "CONTENTS_SLOT_INDEX": integer
 "walkDistO": float
 "moveDist": float
static readonly "FREEZE_HURT_FREQUENCY": integer
 "flyDist": float
 "isInPowderSnow": boolean
static readonly "ATTACHMENTS_NBT_KEY": string
static readonly "ID_TAG": string
 "mainSupportingBlockPos": $Optional<($BlockPos)>
static readonly "PASSENGERS_TAG": string
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_1_0": double
 "blocksBuilding": boolean
 "xRotO": float
 "wasOnFire": boolean
 "zo": double
 "zOld": double
static readonly "TOTAL_AIR_SUPPLY": integer
 "xo": double
 "walkDist": float
 "xOld": double
 "noCulling": boolean
 "wasInPowderSnow": boolean
static readonly "BASE_SAFE_FALL_DISTANCE": integer
 "hurtMarked": boolean
 "horizontalCollision": boolean

constructor(arg0: T)

public "getParent"(): T
public "getAddEntityPacket"(arg0: $ServerEntity$$Type): $Packet<($ClientGamePacketListener)>
public static "forNameOnly"(arg0: string): $ScoreHolder
public static "fromGameProfile"(arg0: $GameProfile$$Type): $ScoreHolder
/**
 * 
 * @deprecated
 */
public "serializeNBT"(arg0: $HolderLookup$Provider$$Type): $Tag
get "parent"(): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PartEntity$$Type<T> = ($PartEntity<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PartEntity_<T> = $PartEntity$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.ModMismatchEvent$MismatchResolutionResult" {
import {$ModMismatchEvent$MismatchedVersionInfo, $ModMismatchEvent$MismatchedVersionInfo$$Type} from "net.neoforged.neoforge.event.ModMismatchEvent$MismatchedVersionInfo"
import {$Record, $Record$$Type} from "java.lang.Record"
import {$ModContainer, $ModContainer$$Type} from "net.neoforged.fml.ModContainer"

export class $ModMismatchEvent$MismatchResolutionResult extends $Record {

constructor(modid: string, versionDifference: $ModMismatchEvent$MismatchedVersionInfo$$Type, resolver: $ModContainer$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "resolver"(): $ModContainer
public "modid"(): string
public "versionDifference"(): $ModMismatchEvent$MismatchedVersionInfo
public "wasSelfResolved"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModMismatchEvent$MismatchResolutionResult$$Type = ({"resolver"?: $ModContainer$$Type, "modid"?: string, "versionDifference"?: $ModMismatchEvent$MismatchedVersionInfo$$Type}) | ([resolver?: $ModContainer$$Type, modid?: string, versionDifference?: $ModMismatchEvent$MismatchedVersionInfo$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModMismatchEvent$MismatchResolutionResult_ = $ModMismatchEvent$MismatchResolutionResult$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBlockGetterExtension" {
import {$AuxiliaryLightManager, $AuxiliaryLightManager$$Type} from "net.neoforged.neoforge.common.world.AuxiliaryLightManager"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$ModelData, $ModelData$$Type} from "net.neoforged.neoforge.client.model.data.ModelData"
import {$ChunkPos, $ChunkPos$$Type} from "net.minecraft.world.level.ChunkPos"

export interface $IBlockGetterExtension {

 "getAuxLightManager"(arg0: $BlockPos$$Type): $AuxiliaryLightManager
 "getAuxLightManager"(arg0: $ChunkPos$$Type): $AuxiliaryLightManager
 "getModelData"(arg0: $BlockPos$$Type): $ModelData
}

export namespace $IBlockGetterExtension {
const probejs$$marker: never
}
export class $IBlockGetterExtension$$Static implements $IBlockGetterExtension {


 "getAuxLightManager"(arg0: $BlockPos$$Type): $AuxiliaryLightManager
 "getAuxLightManager"(arg0: $ChunkPos$$Type): $AuxiliaryLightManager
 "getModelData"(arg0: $BlockPos$$Type): $ModelData
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockGetterExtension$$Type = ($IBlockGetterExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockGetterExtension_ = $IBlockGetterExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IHolderSetExtension" {
import {$IHolderSetExtension$SerializationType, $IHolderSetExtension$SerializationType$$Type} from "net.neoforged.neoforge.common.extensions.IHolderSetExtension$SerializationType"
import {$Runnable, $Runnable$$Type} from "java.lang.Runnable"

export interface $IHolderSetExtension<T> {

 "addInvalidationListener"(arg0: $Runnable$$Type): void
 "serializationType"(): $IHolderSetExtension$SerializationType
}

export namespace $IHolderSetExtension {
const probejs$$marker: never
}
export class $IHolderSetExtension$$Static<T> implements $IHolderSetExtension {


 "addInvalidationListener"(arg0: $Runnable$$Type): void
 "serializationType"(): $IHolderSetExtension$SerializationType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IHolderSetExtension$$Type<T> = ($IHolderSetExtension<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IHolderSetExtension_<T> = $IHolderSetExtension$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.network.event.RegisterConfigurationTasksEvent" {
import {$ConfigurationTask, $ConfigurationTask$$Type} from "net.minecraft.server.network.ConfigurationTask"
import {$Queue, $Queue$$Type} from "java.util.Queue"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ServerConfigurationPacketListener, $ServerConfigurationPacketListener$$Type} from "net.minecraft.network.protocol.configuration.ServerConfigurationPacketListener"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterConfigurationTasksEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ServerConfigurationPacketListener$$Type)

public "register"(arg0: $ConfigurationTask$$Type): void
public "getListener"(): $ServerConfigurationPacketListener
public "getConfigurationTasks"(): $Queue<($ConfigurationTask)>
get "listener"(): $ServerConfigurationPacketListener
get "configurationTasks"(): $Queue<($ConfigurationTask)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterConfigurationTasksEvent$$Type = ($RegisterConfigurationTasksEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterConfigurationTasksEvent_ = $RegisterConfigurationTasksEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderHandEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $RenderHandEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $InteractionHand$$Type, arg1: $PoseStack$$Type, arg2: $MultiBufferSource$$Type, arg3: integer, arg4: float, arg5: float, arg6: float, arg7: float, arg8: $ItemStack$$Type)

public "getEquipProgress"(): float
public "getSwingProgress"(): float
public "getPackedLight"(): integer
public "getPoseStack"(): $PoseStack
public "getPartialTick"(): float
public "getItemStack"(): $ItemStack
public "getHand"(): $InteractionHand
public "getMultiBufferSource"(): $MultiBufferSource
public "getInterpolatedPitch"(): float
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "equipProgress"(): float
get "swingProgress"(): float
get "packedLight"(): integer
get "poseStack"(): $PoseStack
get "partialTick"(): float
get "itemStack"(): $ItemStack
get "hand"(): $InteractionHand
get "multiBufferSource"(): $MultiBufferSource
get "interpolatedPitch"(): float
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderHandEvent$$Type = ($RenderHandEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderHandEvent_ = $RenderHandEvent$$Type;
}}
declare module "net.neoforged.neoforge.attachment.AttachmentType$Builder" {
import {$IAttachmentCopyHandler, $IAttachmentCopyHandler$$Type} from "net.neoforged.neoforge.attachment.IAttachmentCopyHandler"
import {$AttachmentType, $AttachmentType$$Type} from "net.neoforged.neoforge.attachment.AttachmentType"
import {$IAttachmentSerializer, $IAttachmentSerializer$$Type} from "net.neoforged.neoforge.attachment.IAttachmentSerializer"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$Predicate, $Predicate$$Type} from "java.util.function.Predicate"

export class $AttachmentType$Builder<T> {


public "build"(): $AttachmentType<(T)>
public "serialize"(arg0: $Codec$$Type<(T)>, arg1: $Predicate$$Type<(T)>): $AttachmentType$Builder<(T)>
public "serialize"(arg0: $IAttachmentSerializer$$Type<(any), (T)>): $AttachmentType$Builder<(T)>
public "serialize"(arg0: $Codec$$Type<(T)>): $AttachmentType$Builder<(T)>
public "copyHandler"(arg0: $IAttachmentCopyHandler$$Type<(T)>): $AttachmentType$Builder<(T)>
public "copyOnDeath"(): $AttachmentType$Builder<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttachmentType$Builder$$Type<T> = ($AttachmentType$Builder<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttachmentType$Builder_<T> = $AttachmentType$Builder$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.capabilities.BaseCapability" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Class, $Class$$Type} from "java.lang.Class"

export class $BaseCapability<T, C> {


public "name"(): $ResourceLocation
public "contextClass"(): $Class<(C)>
public "typeClass"(): $Class<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BaseCapability$$Type<T, C> = ($BaseCapability<(T), (C)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BaseCapability_<T, C> = $BaseCapability$$Type<(T), (C)>;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$RenderInventoryMobEffects" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$RenderInventoryMobEffects extends $ScreenEvent implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: boolean, arg3: integer)

public "isCompact"(): boolean
public "getAvailableSpace"(): integer
public "getHorizontalOffset"(): integer
public "setCompact"(arg0: boolean): void
public "setHorizontalOffset"(arg0: integer): void
public "addHorizontalOffset"(arg0: integer): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "compact"(): boolean
get "availableSpace"(): integer
get "horizontalOffset"(): integer
set "compact"(value: boolean)
set "horizontalOffset"(value: integer)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$RenderInventoryMobEffects$$Type = ($ScreenEvent$RenderInventoryMobEffects);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$RenderInventoryMobEffects_ = $ScreenEvent$RenderInventoryMobEffects$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.DataMapsUpdatedEvent$UpdateCause" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $DataMapsUpdatedEvent$UpdateCause extends $Enum<($DataMapsUpdatedEvent$UpdateCause)> {
static readonly "CLIENT_SYNC": $DataMapsUpdatedEvent$UpdateCause
static readonly "SERVER_RELOAD": $DataMapsUpdatedEvent$UpdateCause


public static "values"(): ($DataMapsUpdatedEvent$UpdateCause)[]
public static "valueOf"(arg0: string): $DataMapsUpdatedEvent$UpdateCause
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataMapsUpdatedEvent$UpdateCause$$Type = (("client_sync") | ("server_reload"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataMapsUpdatedEvent$UpdateCause_ = $DataMapsUpdatedEvent$UpdateCause$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.EntityTickEvent$Pre" {
import {$EntityTickEvent, $EntityTickEvent$$Type} from "net.neoforged.neoforge.event.tick.EntityTickEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTickEvent$Pre extends $EntityTickEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTickEvent$Pre$$Type = ($EntityTickEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTickEvent$Pre_ = $EntityTickEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Init" {
import {$GuiEventListener, $GuiEventListener$$Type} from "net.minecraft.client.gui.components.events.GuiEventListener"
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$List, $List$$Type} from "java.util.List"

export class $ScreenEvent$Init extends $ScreenEvent {


public "getListenersList"(): $List<($GuiEventListener)>
public "removeListener"(arg0: $GuiEventListener$$Type): void
public "addListener"(arg0: $GuiEventListener$$Type): void
get "listenersList"(): $List<($GuiEventListener)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Init$$Type = ($ScreenEvent$Init);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Init_ = $ScreenEvent$Init$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed$Post" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseButtonPressed, $ScreenEvent$MouseButtonPressed$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed"
import {$ScreenEvent$MouseButtonPressed$Post$Result, $ScreenEvent$MouseButtonPressed$Post$Result$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonPressed$Post$Result"

export class $ScreenEvent$MouseButtonPressed$Post extends $ScreenEvent$MouseButtonPressed {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean)

public "setResult"(arg0: $ScreenEvent$MouseButtonPressed$Post$Result$$Type): void
public "getResult"(): $ScreenEvent$MouseButtonPressed$Post$Result
public "wasClickHandled"(): boolean
public "getMouseY"(): double
public "getMouseX"(): double
public "getClickResult"(): boolean
set "result"(value: $ScreenEvent$MouseButtonPressed$Post$Result$$Type)
get "result"(): $ScreenEvent$MouseButtonPressed$Post$Result
get "mouseY"(): double
get "mouseX"(): double
get "clickResult"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonPressed$Post$$Type = ($ScreenEvent$MouseButtonPressed$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonPressed$Post_ = $ScreenEvent$MouseButtonPressed$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.PlayerTickEvent$Post" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$PlayerTickEvent, $PlayerTickEvent$$Type} from "net.neoforged.neoforge.event.tick.PlayerTickEvent"

export class $PlayerTickEvent$Post extends $PlayerTickEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerTickEvent$Post$$Type = ($PlayerTickEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerTickEvent$Post_ = $PlayerTickEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IBlockEntityRendererExtension" {
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$AABB, $AABB$$Type} from "net.minecraft.world.phys.AABB"

export interface $IBlockEntityRendererExtension<T extends $BlockEntity> {

 "getRenderBoundingBox"(arg0: T): $AABB
}

export namespace $IBlockEntityRendererExtension {
const probejs$$marker: never
}
export class $IBlockEntityRendererExtension$$Static<T extends $BlockEntity> implements $IBlockEntityRendererExtension {


 "getRenderBoundingBox"(arg0: T): $AABB
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockEntityRendererExtension$$Type<T> = ($IBlockEntityRendererExtension<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockEntityRendererExtension_<T> = $IBlockEntityRendererExtension$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$InteractionKeyMappingTriggered" {
import {$InputEvent, $InputEvent$$Type} from "net.neoforged.neoforge.client.event.InputEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$KeyMapping, $KeyMapping$$Type} from "net.minecraft.client.KeyMapping"

export class $InputEvent$InteractionKeyMappingTriggered extends $InputEvent implements $ICancellableEvent {

constructor(arg0: integer, arg1: $KeyMapping$$Type, arg2: $InteractionHand$$Type)

public "getKeyMapping"(): $KeyMapping
public "isPickBlock"(): boolean
public "setSwingHand"(arg0: boolean): void
public "shouldSwingHand"(): boolean
public "isUseItem"(): boolean
public "isAttack"(): boolean
public "getHand"(): $InteractionHand
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "keyMapping"(): $KeyMapping
get "pickBlock"(): boolean
set "swingHand"(value: boolean)
get "useItem"(): boolean
get "attack"(): boolean
get "hand"(): $InteractionHand
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$InteractionKeyMappingTriggered$$Type = ($InputEvent$InteractionKeyMappingTriggered);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$InteractionKeyMappingTriggered_ = $InputEvent$InteractionKeyMappingTriggered$$Type;
}}
declare module "net.neoforged.neoforge.client.RenderTypeGroup" {
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $RenderTypeGroup extends $Record {
static "EMPTY": $RenderTypeGroup

constructor(block: $RenderType$$Type, entity: $RenderType$$Type, entityFabulous: $RenderType$$Type)
constructor(arg0: $RenderType$$Type, arg1: $RenderType$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "isEmpty"(): boolean
public "block"(): $RenderType
public "entity"(): $RenderType
public "entityFabulous"(): $RenderType
get "empty"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderTypeGroup$$Type = ({"entity"?: $RenderType$$Type, "entityFabulous"?: $RenderType$$Type, "block"?: $RenderType$$Type}) | ([entity?: $RenderType$$Type, entityFabulous?: $RenderType$$Type, block?: $RenderType$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderTypeGroup_ = $RenderTypeGroup$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityLeaveLevelEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityLeaveLevelEvent extends $EntityEvent {

constructor(arg0: $Entity$$Type, arg1: $Level$$Type)

public "getLevel"(): $Level
get "level"(): $Level
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityLeaveLevelEvent$$Type = ($EntityLeaveLevelEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityLeaveLevelEvent_ = $EntityLeaveLevelEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.EntityRenderersEvent$RegisterRenderers" {
import {$BlockEntityType, $BlockEntityType$$Type} from "net.minecraft.world.level.block.entity.BlockEntityType"
import {$BlockEntityRendererProvider, $BlockEntityRendererProvider$$Type} from "net.minecraft.client.renderer.blockentity.BlockEntityRendererProvider"
import {$EntityRendererProvider, $EntityRendererProvider$$Type} from "net.minecraft.client.renderer.entity.EntityRendererProvider"
import {$EntityRenderersEvent, $EntityRenderersEvent$$Type} from "net.neoforged.neoforge.client.event.EntityRenderersEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $EntityRenderersEvent$RegisterRenderers extends $EntityRenderersEvent {

constructor()

public "registerBlockEntityRenderer"<T extends $BlockEntity>(arg0: $BlockEntityType$$Type<(T)>, arg1: $BlockEntityRendererProvider$$Type<(T)>): void
public "registerEntityRenderer"<T extends $Entity>(arg0: $EntityType$$Type<(T)>, arg1: $EntityRendererProvider$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityRenderersEvent$RegisterRenderers$$Type = ($EntityRenderersEvent$RegisterRenderers);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityRenderersEvent$RegisterRenderers_ = $EntityRenderersEvent$RegisterRenderers$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderItemInFrameEvent" {
import {$ItemFrameRenderer, $ItemFrameRenderer$$Type} from "net.minecraft.client.renderer.entity.ItemFrameRenderer"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ItemFrame, $ItemFrame$$Type} from "net.minecraft.world.entity.decoration.ItemFrame"

export class $RenderItemInFrameEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ItemFrame$$Type, arg1: $ItemFrameRenderer$$Type<(any)>, arg2: $PoseStack$$Type, arg3: $MultiBufferSource$$Type, arg4: integer)

public "getPackedLight"(): integer
public "getRenderer"(): $ItemFrameRenderer<(any)>
public "getPoseStack"(): $PoseStack
public "getItemStack"(): $ItemStack
public "getItemFrameEntity"(): $ItemFrame
public "getMultiBufferSource"(): $MultiBufferSource
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "packedLight"(): integer
get "renderer"(): $ItemFrameRenderer<(any)>
get "poseStack"(): $PoseStack
get "itemStack"(): $ItemStack
get "itemFrameEntity"(): $ItemFrame
get "multiBufferSource"(): $MultiBufferSource
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderItemInFrameEvent$$Type = ($RenderItemInFrameEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderItemInFrameEvent_ = $RenderItemInFrameEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent$Unload" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent$Unload extends $LevelEvent {

constructor(arg0: $LevelAccessor$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$Unload$$Type = ($LevelEvent$Unload);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent$Unload_ = $LevelEvent$Unload$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDestroyBlockEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $LivingDestroyBlockEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type)

public "getState"(): $BlockState
public "getPos"(): $BlockPos
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "state"(): $BlockState
get "pos"(): $BlockPos
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDestroyBlockEvent$$Type = ($LivingDestroyBlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDestroyBlockEvent_ = $LivingDestroyBlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.model.geometry.IUnbakedGeometry" {
import {$TextureAtlasSprite, $TextureAtlasSprite$$Type} from "net.minecraft.client.renderer.texture.TextureAtlasSprite"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Material, $Material$$Type} from "net.minecraft.client.resources.model.Material"
import {$ItemOverrides, $ItemOverrides$$Type} from "net.minecraft.client.renderer.block.model.ItemOverrides"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$IGeometryBakingContext, $IGeometryBakingContext$$Type} from "net.neoforged.neoforge.client.model.geometry.IGeometryBakingContext"
import {$Set, $Set$$Type} from "java.util.Set"
import {$ModelState, $ModelState$$Type} from "net.minecraft.client.resources.model.ModelState"
import {$ModelBaker, $ModelBaker$$Type} from "net.minecraft.client.resources.model.ModelBaker"
import {$UnbakedModel, $UnbakedModel$$Type} from "net.minecraft.client.resources.model.UnbakedModel"

export interface $IUnbakedGeometry<T extends $IUnbakedGeometry<(T)>> {

 "bake"(arg0: $IGeometryBakingContext$$Type, arg1: $ModelBaker$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>, arg3: $ModelState$$Type, arg4: $ItemOverrides$$Type): $BakedModel
 "getConfigurableComponentNames"(): $Set<(string)>
 "resolveParents"(arg0: $Function$$Type<($ResourceLocation), ($UnbakedModel$$Type)>, arg1: $IGeometryBakingContext$$Type): void

(arg0: $IGeometryBakingContext, arg1: $ModelBaker, arg2: $Function<($Material), ($TextureAtlasSprite$$Type)>, arg3: $ModelState, arg4: $ItemOverrides): $BakedModel$$Type
get "configurableComponentNames"(): $Set<(string)>
}

export namespace $IUnbakedGeometry {
const probejs$$marker: never
}
export class $IUnbakedGeometry$$Static<T extends $IUnbakedGeometry<(T)>> implements $IUnbakedGeometry {


 "bake"(arg0: $IGeometryBakingContext$$Type, arg1: $ModelBaker$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>, arg3: $ModelState$$Type, arg4: $ItemOverrides$$Type): $BakedModel
 "getConfigurableComponentNames"(): $Set<(string)>
 "resolveParents"(arg0: $Function$$Type<($ResourceLocation), ($UnbakedModel$$Type)>, arg1: $IGeometryBakingContext$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IUnbakedGeometry$$Type<T> = ((arg0: $IGeometryBakingContext, arg1: $ModelBaker, arg2: $Function<($Material), ($TextureAtlasSprite)>, arg3: $ModelState, arg4: $ItemOverrides) => $BakedModel$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IUnbakedGeometry_<T> = $IUnbakedGeometry$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.extensions.IHolderSetExtension$SerializationType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $IHolderSetExtension$SerializationType extends $Enum<($IHolderSetExtension$SerializationType)> {
static readonly "STRING": $IHolderSetExtension$SerializationType
static readonly "UNKNOWN": $IHolderSetExtension$SerializationType
static readonly "OBJECT": $IHolderSetExtension$SerializationType
static readonly "LIST": $IHolderSetExtension$SerializationType


public static "values"(): ($IHolderSetExtension$SerializationType)[]
public static "valueOf"(arg0: string): $IHolderSetExtension$SerializationType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IHolderSetExtension$SerializationType$$Type = (("unknown") | ("string") | ("list") | ("object"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IHolderSetExtension$SerializationType_ = $IHolderSetExtension$SerializationType$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$EntityPlaceEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$BlockSnapshot, $BlockSnapshot$$Type} from "net.neoforged.neoforge.common.util.BlockSnapshot"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$EntityPlaceEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $BlockSnapshot$$Type, arg1: $BlockState$$Type, arg2: $Entity$$Type)

public "getEntity"(): $Entity
public "getPlacedBlock"(): $BlockState
public "getBlockSnapshot"(): $BlockSnapshot
public "getPlacedAgainst"(): $BlockState
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "entity"(): $Entity
get "placedBlock"(): $BlockState
get "blockSnapshot"(): $BlockSnapshot
get "placedAgainst"(): $BlockState
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$EntityPlaceEvent$$Type = ($BlockEvent$EntityPlaceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$EntityPlaceEvent_ = $BlockEvent$EntityPlaceEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.TagsUpdatedEvent" {
import {$TagsUpdatedEvent$UpdateCause, $TagsUpdatedEvent$UpdateCause$$Type} from "net.neoforged.neoforge.event.TagsUpdatedEvent$UpdateCause"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $TagsUpdatedEvent extends $Event {

constructor(arg0: $RegistryAccess$$Type, arg1: boolean, arg2: boolean)

public "shouldUpdateStaticData"(): boolean
public "getRegistryAccess"(): $RegistryAccess
public "getUpdateCause"(): $TagsUpdatedEvent$UpdateCause
get "registryAccess"(): $RegistryAccess
get "updateCause"(): $TagsUpdatedEvent$UpdateCause
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TagsUpdatedEvent$$Type = ($TagsUpdatedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TagsUpdatedEvent_ = $TagsUpdatedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.EntityRenderersEvent$AddLayers" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$EntityRenderer, $EntityRenderer$$Type} from "net.minecraft.client.renderer.entity.EntityRenderer"
import {$Map, $Map$$Type} from "java.util.Map"
import {$PlayerSkin$Model, $PlayerSkin$Model$$Type} from "net.minecraft.client.resources.PlayerSkin$Model"
import {$Set, $Set$$Type} from "java.util.Set"
import {$EntityRendererProvider$Context, $EntityRendererProvider$Context$$Type} from "net.minecraft.client.renderer.entity.EntityRendererProvider$Context"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$EntityRenderersEvent, $EntityRenderersEvent$$Type} from "net.neoforged.neoforge.client.event.EntityRenderersEvent"
import {$EntityModelSet, $EntityModelSet$$Type} from "net.minecraft.client.model.geom.EntityModelSet"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $EntityRenderersEvent$AddLayers extends $EntityRenderersEvent {

constructor(arg0: $Map$$Type<($EntityType$$Type<(any)>), ($EntityRenderer$$Type<(any)>)>, arg1: $Map$$Type<($PlayerSkin$Model$$Type), ($EntityRenderer$$Type<($Player$$Type)>)>, arg2: $EntityRendererProvider$Context$$Type)

public "getContext"(): $EntityRendererProvider$Context
public "getSkin"<R extends $EntityRenderer<($Player)>>(arg0: $PlayerSkin$Model$$Type): R
public "getRenderer"<T extends $Entity, R extends $EntityRenderer<(T)>>(arg0: $EntityType$$Type<(T)>): R
public "getEntityModels"(): $EntityModelSet
public "getSkins"(): $Set<($PlayerSkin$Model)>
public "getEntityTypes"(): $Set<($EntityType<(any)>)>
get "context"(): $EntityRendererProvider$Context
get "entityModels"(): $EntityModelSet
get "skins"(): $Set<($PlayerSkin$Model)>
get "entityTypes"(): $Set<($EntityType<(any)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityRenderersEvent$AddLayers$$Type = ($EntityRenderersEvent$AddLayers);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityRenderersEvent$AddLayers_ = $EntityRenderersEvent$AddLayers$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$PortalSpawnEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PortalShape, $PortalShape$$Type} from "net.minecraft.world.level.portal.PortalShape"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$PortalSpawnEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $PortalShape$$Type)

public "getPortalSize"(): $PortalShape
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "portalSize"(): $PortalShape
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$PortalSpawnEvent$$Type = ($BlockEvent$PortalSpawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$PortalSpawnEvent_ = $BlockEvent$PortalSpawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent$EnderEntity" {
import {$EntityTeleportEvent, $EntityTeleportEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityTeleportEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $EntityTeleportEvent$EnderEntity extends $EntityTeleportEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: double, arg2: double, arg3: double)

public "getEntityLiving"(): $LivingEntity
get "entityLiving"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$EnderEntity$$Type = ($EntityTeleportEvent$EnderEntity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent$EnderEntity_ = $EntityTeleportEvent$EnderEntity$$Type;
}}
declare module "net.neoforged.neoforgespi.locating.ForgeFeature$Bound" {
import {$Record, $Record$$Type} from "java.lang.Record"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"

export class $ForgeFeature$Bound extends $Record {

constructor(featureName: string, featureBound: string, modInfo: $IModInfo$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "bound"<T>(): T
public "featureName"(): string
public "featureBound"(): string
public "modInfo"(): $IModInfo
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ForgeFeature$Bound$$Type = ({"featureName"?: string, "featureBound"?: string, "modInfo"?: $IModInfo$$Type}) | ([featureName?: string, featureBound?: string, modInfo?: $IModInfo$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ForgeFeature$Bound_ = $ForgeFeature$Bound$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerSpawnPhantomsEvent$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $PlayerSpawnPhantomsEvent$Result extends $Enum<($PlayerSpawnPhantomsEvent$Result)> {
static readonly "DENY": $PlayerSpawnPhantomsEvent$Result
static readonly "ALLOW": $PlayerSpawnPhantomsEvent$Result
static readonly "DEFAULT": $PlayerSpawnPhantomsEvent$Result


public static "values"(): ($PlayerSpawnPhantomsEvent$Result)[]
public static "valueOf"(arg0: string): $PlayerSpawnPhantomsEvent$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerSpawnPhantomsEvent$Result$$Type = (("allow") | ("default") | ("deny"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerSpawnPhantomsEvent$Result_ = $PlayerSpawnPhantomsEvent$Result$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Init$Pre" {
import {$GuiEventListener, $GuiEventListener$$Type} from "net.minecraft.client.gui.components.events.GuiEventListener"
import {$ScreenEvent$Init, $ScreenEvent$Init$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$Init"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $ScreenEvent$Init$Pre extends $ScreenEvent$Init implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: $List$$Type<($GuiEventListener$$Type)>, arg2: $Consumer$$Type<($GuiEventListener)>, arg3: $Consumer$$Type<($GuiEventListener)>)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Init$Pre$$Type = ($ScreenEvent$Init$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Init$Pre_ = $ScreenEvent$Init$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.event.MovementInputUpdateEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Input, $Input$$Type} from "net.minecraft.client.player.Input"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $MovementInputUpdateEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Input$$Type)

public "getInput"(): $Input
public "getEntity"(): $Entity
get "input"(): $Input
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MovementInputUpdateEvent$$Type = ($MovementInputUpdateEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MovementInputUpdateEvent_ = $MovementInputUpdateEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PermissionsChangedEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PermissionsChangedEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: integer, arg2: integer)

public "getNewLevel"(): integer
public "getOldLevel"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "newLevel"(): integer
get "oldLevel"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionsChangedEvent$$Type = ($PermissionsChangedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionsChangedEvent_ = $PermissionsChangedEvent$$Type;
}}
declare module "net.neoforged.neoforge.attachment.AttachmentType" {
import {$IAttachmentHolder, $IAttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.IAttachmentHolder"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$INBTSerializable, $INBTSerializable$$Type} from "net.neoforged.neoforge.common.util.INBTSerializable"
import {$AttachmentType$Builder, $AttachmentType$Builder$$Type} from "net.neoforged.neoforge.attachment.AttachmentType$Builder"

export class $AttachmentType<T> {


public static "builder"<T>(arg0: $Function$$Type<($IAttachmentHolder), (T)>): $AttachmentType$Builder<(T)>
public static "builder"<T>(arg0: $Supplier$$Type<(T)>): $AttachmentType$Builder<(T)>
public static "serializable"<S extends $Tag, T extends $INBTSerializable<(S)>>(arg0: $Function$$Type<($IAttachmentHolder), (T)>): $AttachmentType$Builder<(T)>
public static "serializable"<S extends $Tag, T extends $INBTSerializable<(S)>>(arg0: $Supplier$$Type<(T)>): $AttachmentType$Builder<(T)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeAttachmentTypes
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeAttachmentTypesTag
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttachmentType$$Type<T> = (Special.NeoforgeAttachmentTypes);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttachmentType_<T> = $AttachmentType$$Type<(T)>;
}}
declare module "net.neoforged.neoforgespi.language.IModInfo$Ordering" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $IModInfo$Ordering extends $Enum<($IModInfo$Ordering)> {
static readonly "BEFORE": $IModInfo$Ordering
static readonly "AFTER": $IModInfo$Ordering
static readonly "NONE": $IModInfo$Ordering


public static "values"(): ($IModInfo$Ordering)[]
public static "valueOf"(arg0: string): $IModInfo$Ordering
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModInfo$Ordering$$Type = (("before") | ("after") | ("none"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModInfo$Ordering_ = $IModInfo$Ordering$$Type;
}}
declare module "net.neoforged.neoforge.registries.callback.RegistryCallback" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $RegistryCallback<T> {

}

export namespace $RegistryCallback {
const probejs$$marker: never
}
export class $RegistryCallback$$Static<T> implements $RegistryCallback {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegistryCallback$$Type<T> = ($RegistryCallback<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegistryCallback_<T> = $RegistryCallback$$Type<(T)>;
}}
declare module "net.neoforged.neoforgespi.language.IModFileInfo" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$IModFile, $IModFile$$Type} from "net.neoforged.neoforgespi.locating.IModFile"
import {$IModFileInfo$LanguageSpec, $IModFileInfo$LanguageSpec$$Type} from "net.neoforged.neoforgespi.language.IModFileInfo$LanguageSpec"
import {$IConfigurable, $IConfigurable$$Type} from "net.neoforged.neoforgespi.language.IConfigurable"
import {$List, $List$$Type} from "java.util.List"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"

export interface $IModFileInfo {

 "moduleName"(): string
 "getFile"(): $IModFile
 "usesServices"(): $List<(string)>
 "showAsResourcePack"(): boolean
 "getFileProperties"(): $Map<(string), (any)>
 "showAsDataPack"(): boolean
 "requiredLanguageLoaders"(): $List<($IModFileInfo$LanguageSpec)>
 "versionString"(): string
 "getConfig"(): $IConfigurable
 "getMods"(): $List<($IModInfo)>
 "getLicense"(): string
get "file"(): $IModFile
get "fileProperties"(): $Map<(string), (any)>
get "config"(): $IConfigurable
get "mods"(): $List<($IModInfo)>
get "license"(): string
}

export namespace $IModFileInfo {
const probejs$$marker: never
}
export class $IModFileInfo$$Static implements $IModFileInfo {


 "moduleName"(): string
 "getFile"(): $IModFile
 "usesServices"(): $List<(string)>
 "showAsResourcePack"(): boolean
 "getFileProperties"(): $Map<(string), (any)>
 "showAsDataPack"(): boolean
 "requiredLanguageLoaders"(): $List<($IModFileInfo$LanguageSpec)>
 "versionString"(): string
 "getConfig"(): $IConfigurable
 "getMods"(): $List<($IModInfo)>
 "getLicense"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModFileInfo$$Type = ($IModFileInfo);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModFileInfo_ = $IModFileInfo$$Type;
}}
declare module "net.neoforged.neoforge.client.textures.SpriteContentsConstructor" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$NativeImage, $NativeImage$$Type} from "com.mojang.blaze3d.platform.NativeImage"
import {$SpriteContents, $SpriteContents$$Type} from "net.minecraft.client.renderer.texture.SpriteContents"
import {$ResourceMetadata, $ResourceMetadata$$Type} from "net.minecraft.server.packs.resources.ResourceMetadata"
import {$FrameSize, $FrameSize$$Type} from "net.minecraft.client.resources.metadata.animation.FrameSize"

export interface $SpriteContentsConstructor {

 "create"(arg0: $ResourceLocation$$Type, arg1: $FrameSize$$Type, arg2: $NativeImage$$Type, arg3: $ResourceMetadata$$Type): $SpriteContents

(arg0: $ResourceLocation, arg1: $FrameSize, arg2: $NativeImage, arg3: $ResourceMetadata): $SpriteContents$$Type
}

export namespace $SpriteContentsConstructor {
const probejs$$marker: never
}
export class $SpriteContentsConstructor$$Static implements $SpriteContentsConstructor {


 "create"(arg0: $ResourceLocation$$Type, arg1: $FrameSize$$Type, arg2: $NativeImage$$Type, arg3: $ResourceMetadata$$Type): $SpriteContents
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SpriteContentsConstructor$$Type = ((arg0: $ResourceLocation, arg1: $FrameSize, arg2: $NativeImage, arg3: $ResourceMetadata) => $SpriteContents$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SpriteContentsConstructor_ = $SpriteContentsConstructor$$Type;
}}
declare module "net.neoforged.neoforge.common.enums.BubbleColumnDirection" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $BubbleColumnDirection extends $Enum<($BubbleColumnDirection)> {
static readonly "DOWNWARD": $BubbleColumnDirection
static readonly "UPWARD": $BubbleColumnDirection
static readonly "NONE": $BubbleColumnDirection


public static "values"(): ($BubbleColumnDirection)[]
public static "valueOf"(arg0: string): $BubbleColumnDirection
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BubbleColumnDirection$$Type = (("upward") | ("downward") | ("none"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BubbleColumnDirection_ = $BubbleColumnDirection$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterDimensionTransitionScreenEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Pair, $Pair$$Type} from "com.mojang.datafixers.util.Pair"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$DimensionTransitionScreenManager$ReceivingLevelScreenFactory, $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type} from "net.neoforged.neoforge.client.DimensionTransitionScreenManager$ReceivingLevelScreenFactory"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterDimensionTransitionScreenEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($Pair$$Type<($ResourceKey$$Type<($Level$$Type)>), ($ResourceKey$$Type<($Level$$Type)>)>), ($DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type)>, arg1: $Map$$Type<($ResourceKey$$Type<($Level$$Type)>), ($DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type)>, arg2: $Map$$Type<($ResourceKey$$Type<($Level$$Type)>), ($DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type)>)

public "registerIncomingEffect"(arg0: $ResourceKey$$Type<($Level)>, arg1: $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type): boolean
public "registerConditionalEffect"(arg0: $ResourceKey$$Type<($Level)>, arg1: $ResourceKey$$Type<($Level)>, arg2: $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type): boolean
public "registerOutgoingEffect"(arg0: $ResourceKey$$Type<($Level)>, arg1: $DimensionTransitionScreenManager$ReceivingLevelScreenFactory$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterDimensionTransitionScreenEvent$$Type = ($RegisterDimensionTransitionScreenEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterDimensionTransitionScreenEvent_ = $RegisterDimensionTransitionScreenEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.chunk.TicketSet" {
import {$LongSet, $LongSet$$Type} from "it.unimi.dsi.fastutil.longs.LongSet"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $TicketSet extends $Record {

constructor(nonTicking: $LongSet$$Type, ticking: $LongSet$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "ticking"(): $LongSet
public "nonTicking"(): $LongSet
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TicketSet$$Type = ({"ticking"?: $LongSet$$Type, "nonTicking"?: $LongSet$$Type}) | ([ticking?: $LongSet$$Type, nonTicking?: $LongSet$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TicketSet_ = $TicketSet$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IMinecraftExtension" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$Locale, $Locale$$Type} from "java.util.Locale"

export interface $IMinecraftExtension {

 "getLocale"(): $Locale
 "popGuiLayer"(): void
 "pushGuiLayer"(arg0: $Screen$$Type): void
get "locale"(): $Locale
}

export namespace $IMinecraftExtension {
const probejs$$marker: never
}
export class $IMinecraftExtension$$Static implements $IMinecraftExtension {


 "getLocale"(): $Locale
 "popGuiLayer"(): void
 "pushGuiLayer"(arg0: $Screen$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMinecraftExtension$$Type = ($IMinecraftExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMinecraftExtension_ = $IMinecraftExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IAbstractMinecartExtension" {
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export interface $IAbstractMinecartExtension {

 "getComparatorLevel"(): integer
 "setCurrentCartSpeedCapOnRail"(arg0: float): void
 "getCurrentCartSpeedCapOnRail"(): float
 "getSlopeAdjustment"(): double
 "canBeRidden"(): boolean
 "moveMinecartOnRail"(arg0: $BlockPos$$Type): void
 "isPoweredCart"(): boolean
 "setCanUseRail"(arg0: boolean): void
 "setDragAir"(arg0: double): void
 "getMaxCartSpeedOnRail"(): float
 "getMaxSpeedAirLateral"(): float
 "setMaxSpeedAirLateral"(arg0: float): void
 "getMaxSpeedAirVertical"(): float
 "setMaxSpeedAirVertical"(arg0: float): void
 "getCurrentRailPosition"(): $BlockPos
 "shouldDoRailFunctions"(): boolean
 "getMaxSpeedWithRail"(): double
 "canUseRail"(): boolean
 "getDragAir"(): double
get "comparatorLevel"(): integer
set "currentCartSpeedCapOnRail"(value: float)
get "currentCartSpeedCapOnRail"(): float
get "slopeAdjustment"(): double
get "poweredCart"(): boolean
set "dragAir"(value: double)
get "maxCartSpeedOnRail"(): float
get "maxSpeedAirLateral"(): float
set "maxSpeedAirLateral"(value: float)
get "maxSpeedAirVertical"(): float
set "maxSpeedAirVertical"(value: float)
get "currentRailPosition"(): $BlockPos
get "maxSpeedWithRail"(): double
get "dragAir"(): double
}

export namespace $IAbstractMinecartExtension {
const DEFAULT_AIR_DRAG: double
const DEFAULT_MAX_SPEED_AIR_VERTICAL: float
const DEFAULT_MAX_SPEED_AIR_LATERAL: float
const probejs$$marker: never
}
export class $IAbstractMinecartExtension$$Static implements $IAbstractMinecartExtension {
static readonly "DEFAULT_AIR_DRAG": double
static readonly "DEFAULT_MAX_SPEED_AIR_VERTICAL": float
static readonly "DEFAULT_MAX_SPEED_AIR_LATERAL": float


 "getComparatorLevel"(): integer
 "setCurrentCartSpeedCapOnRail"(arg0: float): void
 "getCurrentCartSpeedCapOnRail"(): float
 "getSlopeAdjustment"(): double
 "canBeRidden"(): boolean
 "moveMinecartOnRail"(arg0: $BlockPos$$Type): void
 "isPoweredCart"(): boolean
 "setCanUseRail"(arg0: boolean): void
 "setDragAir"(arg0: double): void
 "getMaxCartSpeedOnRail"(): float
 "getMaxSpeedAirLateral"(): float
 "setMaxSpeedAirLateral"(arg0: float): void
 "getMaxSpeedAirVertical"(): float
 "setMaxSpeedAirVertical"(arg0: float): void
 "getCurrentRailPosition"(): $BlockPos
 "shouldDoRailFunctions"(): boolean
 "getMaxSpeedWithRail"(): double
 "canUseRail"(): boolean
 "getDragAir"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAbstractMinecartExtension$$Type = ($IAbstractMinecartExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAbstractMinecartExtension_ = $IAbstractMinecartExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityEvent$Size" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Pose, $Pose$$Type} from "net.minecraft.world.entity.Pose"
import {$EntityDimensions, $EntityDimensions$$Type} from "net.minecraft.world.entity.EntityDimensions"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityEvent$Size extends $EntityEvent {

constructor(arg0: $Entity$$Type, arg1: $Pose$$Type, arg2: $EntityDimensions$$Type)
constructor(arg0: $Entity$$Type, arg1: $Pose$$Type, arg2: $EntityDimensions$$Type, arg3: $EntityDimensions$$Type)

public "setNewSize"(arg0: $EntityDimensions$$Type): void
public "getOldSize"(): $EntityDimensions
public "getNewSize"(): $EntityDimensions
public "getPose"(): $Pose
set "newSize"(value: $EntityDimensions$$Type)
get "oldSize"(): $EntityDimensions
get "newSize"(): $EntityDimensions
get "pose"(): $Pose
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityEvent$Size$$Type = ($EntityEvent$Size);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityEvent$Size_ = $EntityEvent$Size$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ModifyCustomSpawnersEvent" {
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$CustomSpawner, $CustomSpawner$$Type} from "net.minecraft.world.level.CustomSpawner"

export class $ModifyCustomSpawnersEvent extends $Event {

constructor(arg0: $ServerLevel$$Type, arg1: $List$$Type<($CustomSpawner$$Type)>)

public "getLevel"(): $ServerLevel
public "getCustomSpawners"(): $List<($CustomSpawner)>
public "addCustomSpawner"(arg0: $CustomSpawner$$Type): void
get "level"(): $ServerLevel
get "customSpawners"(): $List<($CustomSpawner)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifyCustomSpawnersEvent$$Type = ($ModifyCustomSpawnersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifyCustomSpawnersEvent_ = $ModifyCustomSpawnersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEnchantItemEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$EnchantmentInstance, $EnchantmentInstance$$Type} from "net.minecraft.world.item.enchantment.EnchantmentInstance"
import {$List, $List$$Type} from "java.util.List"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEnchantItemEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $List$$Type<($EnchantmentInstance$$Type)>)

public "getEnchantedItem"(): $ItemStack
public "getEnchantments"(): $List<($EnchantmentInstance)>
public "getEntity"(): $Entity
get "enchantedItem"(): $ItemStack
get "enchantments"(): $List<($EnchantmentInstance)>
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEnchantItemEvent$$Type = ($PlayerEnchantItemEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEnchantItemEvent_ = $PlayerEnchantItemEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IPlayerExtension" {
import {$MenuProvider, $MenuProvider$$Type} from "net.minecraft.world.MenuProvider"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$OptionalInt, $OptionalInt$$Type} from "java.util.OptionalInt"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export interface $IPlayerExtension {

 "isCloseEnough"(arg0: $Entity$$Type, arg1: double): boolean
 "isFakePlayer"(): boolean
 "openMenu"(arg0: $MenuProvider$$Type, arg1: $Consumer$$Type<($RegistryFriendlyByteBuf)>): $OptionalInt
 "openMenu"(arg0: $MenuProvider$$Type, arg1: $BlockPos$$Type): $OptionalInt
 "mayFly"(): boolean
get "fakePlayer"(): boolean
}

export namespace $IPlayerExtension {
const probejs$$marker: never
}
export class $IPlayerExtension$$Static implements $IPlayerExtension {


 "isCloseEnough"(arg0: $Entity$$Type, arg1: double): boolean
 "isFakePlayer"(): boolean
 "openMenu"(arg0: $MenuProvider$$Type, arg1: $Consumer$$Type<($RegistryFriendlyByteBuf)>): $OptionalInt
 "openMenu"(arg0: $MenuProvider$$Type, arg1: $BlockPos$$Type): $OptionalInt
 "mayFly"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPlayerExtension$$Type = ($IPlayerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPlayerExtension_ = $IPlayerExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityJoinLevelEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityJoinLevelEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: $Level$$Type)
constructor(arg0: $Entity$$Type, arg1: $Level$$Type, arg2: boolean)

public "getLevel"(): $Level
public "loadedFromDisk"(): boolean
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "level"(): $Level
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityJoinLevelEvent$$Type = ($EntityJoinLevelEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityJoinLevelEvent_ = $EntityJoinLevelEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.NewRegistryEvent" {
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RegistryBuilder, $RegistryBuilder$$Type} from "net.neoforged.neoforge.registries.RegistryBuilder"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $NewRegistryEvent extends $Event implements $IModBusEvent {


public "register"<T>(arg0: $Registry$$Type<(T)>): void
public "create"<T>(arg0: $RegistryBuilder$$Type<(T)>): $Registry<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NewRegistryEvent$$Type = ($NewRegistryEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NewRegistryEvent_ = $NewRegistryEvent$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContextKey" {
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$PermissionDynamicContext, $PermissionDynamicContext$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContext"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $PermissionDynamicContextKey<T> extends $Record {

constructor(typeToken: $Class$$Type<(T)>, name: string, serializer: $Function$$Type<(T), (string)>)

public "name"(): string
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "serializer"(): $Function<(T), (string)>
public "createContext"(arg0: T): $PermissionDynamicContext<(T)>
public "typeToken"(): $Class<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionDynamicContextKey$$Type<T> = ({"name"?: string, "typeToken"?: $Class$$Type<(any)>, "serializer"?: $Function$$Type<(any), (string)>}) | ([name?: string, typeToken?: $Class$$Type<(any)>, serializer?: $Function$$Type<(any), (string)>]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionDynamicContextKey_<T> = $PermissionDynamicContextKey$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableBiomeInfo" {
import {$List, $List$$Type} from "java.util.List"
import {$Biome, $Biome$$Type} from "net.minecraft.world.level.biome.Biome"
import {$BiomeModifier, $BiomeModifier$$Type} from "net.neoforged.neoforge.common.world.BiomeModifier"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"
import {$ModifiableBiomeInfo$BiomeInfo, $ModifiableBiomeInfo$BiomeInfo$$Type} from "net.neoforged.neoforge.common.world.ModifiableBiomeInfo$BiomeInfo"

export class $ModifiableBiomeInfo {

constructor(arg0: $ModifiableBiomeInfo$BiomeInfo$$Type)

public "get"(): $ModifiableBiomeInfo$BiomeInfo
public "getOriginalBiomeInfo"(): $ModifiableBiomeInfo$BiomeInfo
public "applyBiomeModifiers"(arg0: $Holder$$Type<($Biome)>, arg1: $List$$Type<($BiomeModifier$$Type)>, arg2: $RegistryAccess$$Type): boolean
public "getModifiedBiomeInfo"(): $ModifiableBiomeInfo$BiomeInfo
get "originalBiomeInfo"(): $ModifiableBiomeInfo$BiomeInfo
get "modifiedBiomeInfo"(): $ModifiableBiomeInfo$BiomeInfo
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableBiomeInfo$$Type = ($ModifiableBiomeInfo);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableBiomeInfo_ = $ModifiableBiomeInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkDataEvent" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$ChunkAccess, $ChunkAccess$$Type} from "net.minecraft.world.level.chunk.ChunkAccess"
import {$ChunkEvent, $ChunkEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkEvent"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $ChunkDataEvent extends $ChunkEvent {

constructor(arg0: $ChunkAccess$$Type, arg1: $CompoundTag$$Type)
constructor(arg0: $ChunkAccess$$Type, arg1: $LevelAccessor$$Type, arg2: $CompoundTag$$Type)

public "getData"(): $CompoundTag
get "data"(): $CompoundTag
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkDataEvent$$Type = ($ChunkDataEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkDataEvent_ = $ChunkDataEvent$$Type;
}}
declare module "net.neoforged.fml.config.IConfigSpec$ILoadedConfig" {
import {$CommentedConfig, $CommentedConfig$$Type} from "com.electronwill.nightconfig.core.CommentedConfig"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export interface $IConfigSpec$ILoadedConfig {

 "save"(): void
 "config"(): $CommentedConfig
}

export namespace $IConfigSpec$ILoadedConfig {
const probejs$$marker: never
}
export class $IConfigSpec$ILoadedConfig$$Static implements $IConfigSpec$ILoadedConfig {


 "save"(): void
 "config"(): $CommentedConfig
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IConfigSpec$ILoadedConfig$$Type = ($IConfigSpec$ILoadedConfig);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IConfigSpec$ILoadedConfig_ = $IConfigSpec$ILoadedConfig$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent$Stop" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityUseItemEvent, $LivingEntityUseItemEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent"

export class $LivingEntityUseItemEvent$Stop extends $LivingEntityUseItemEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEntityUseItemEvent$Stop$$Type = ($LivingEntityUseItemEvent$Stop);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEntityUseItemEvent$Stop_ = $LivingEntityUseItemEvent$Stop$$Type;
}}
declare module "net.neoforged.neoforge.mixins.BlockEntityTypeAccessor" {
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$Set, $Set$$Type} from "java.util.Set"

export interface $BlockEntityTypeAccessor {

 "neoforge$setValidBlocks"(arg0: $Set$$Type<($Block$$Type)>): void

(arg0: $Set<($Block)>): void
}

export namespace $BlockEntityTypeAccessor {
const probejs$$marker: never
}
export class $BlockEntityTypeAccessor$$Static implements $BlockEntityTypeAccessor {


 "neoforge$setValidBlocks"(arg0: $Set$$Type<($Block$$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEntityTypeAccessor$$Type = ((arg0: $Set<($Block)>) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEntityTypeAccessor_ = $BlockEntityTypeAccessor$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent$PotentialSpawns" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$MobCategory, $MobCategory$$Type} from "net.minecraft.world.entity.MobCategory"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$WeightedRandomList, $WeightedRandomList$$Type} from "net.minecraft.util.random.WeightedRandomList"
import {$MobSpawnSettings$SpawnerData, $MobSpawnSettings$SpawnerData$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings$SpawnerData"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent$PotentialSpawns extends $LevelEvent implements $ICancellableEvent {

constructor(arg0: $LevelAccessor$$Type, arg1: $MobCategory$$Type, arg2: $BlockPos$$Type, arg3: $WeightedRandomList$$Type<($MobSpawnSettings$SpawnerData$$Type)>)

public "getSpawnerDataList"(): $List<($MobSpawnSettings$SpawnerData)>
public "getMobCategory"(): $MobCategory
public "addSpawnerData"(arg0: $MobSpawnSettings$SpawnerData$$Type): void
public "removeSpawnerData"(arg0: $MobSpawnSettings$SpawnerData$$Type): boolean
public "getPos"(): $BlockPos
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "spawnerDataList"(): $List<($MobSpawnSettings$SpawnerData)>
get "mobCategory"(): $MobCategory
get "pos"(): $BlockPos
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$PotentialSpawns$$Type = ($LevelEvent$PotentialSpawns);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent$PotentialSpawns_ = $LevelEvent$PotentialSpawns$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobEffectEvent$Remove" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$MobEffectEvent, $MobEffectEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobEffectEvent"
import {$EffectCure, $EffectCure$$Type} from "net.neoforged.neoforge.common.EffectCure"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$MobEffect, $MobEffect$$Type} from "net.minecraft.world.effect.MobEffect"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $MobEffectEvent$Remove extends $MobEffectEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $Holder$$Type<($MobEffect)>, arg2: $EffectCure$$Type)
constructor(arg0: $LivingEntity$$Type, arg1: $MobEffectInstance$$Type, arg2: $EffectCure$$Type)

public "getCure"(): $EffectCure
public "getEffect"(): $Holder<($MobEffect)>
public "getEffectInstance"(): $MobEffectInstance
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "cure"(): $EffectCure
get "effect"(): $Holder<($MobEffect)>
get "effectInstance"(): $MobEffectInstance
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobEffectEvent$Remove$$Type = ($MobEffectEvent$Remove);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobEffectEvent$Remove_ = $MobEffectEvent$Remove$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingConversionEvent$Post" {
import {$LivingConversionEvent, $LivingConversionEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingConversionEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingConversionEvent$Post extends $LivingConversionEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $LivingEntity$$Type)

public "getOutcome"(): $LivingEntity
get "outcome"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingConversionEvent$Post$$Type = ($LivingConversionEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingConversionEvent$Post_ = $LivingConversionEvent$Post$$Type;
}}
declare module "net.neoforged.fml.ModContainer" {
import {$ModConfig$Type, $ModConfig$Type$$Type} from "net.neoforged.fml.config.ModConfig$Type"
import {$IEventBus, $IEventBus$$Type} from "net.neoforged.bus.api.IEventBus"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$EventPriority, $EventPriority$$Type} from "net.neoforged.bus.api.EventPriority"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IExtensionPoint, $IExtensionPoint$$Type} from "net.neoforged.fml.IExtensionPoint"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$IConfigSpec, $IConfigSpec$$Type} from "net.neoforged.fml.config.IConfigSpec"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $ModContainer {

constructor(arg0: $IModInfo$$Type)

public "getNamespace"(): string
public "registerExtensionPoint"<T extends $IExtensionPoint>(arg0: $Class$$Type<(T)>, arg1: T): void
public "registerExtensionPoint"<T extends $IExtensionPoint>(arg0: $Class$$Type<(T)>, arg1: $Supplier$$Type<(T)>): void
public "registerConfig"(arg0: $ModConfig$Type$$Type, arg1: $IConfigSpec$$Type, arg2: string): void
public "registerConfig"(arg0: $ModConfig$Type$$Type, arg1: $IConfigSpec$$Type): void
public "getCustomExtension"<T extends $IExtensionPoint>(arg0: $Class$$Type<(T)>): $Optional<(T)>
public "getEventBus"(): $IEventBus
public "acceptEvent"<T extends ($Event) & ($IModBusEvent)>(arg0: T): void
public "acceptEvent"<T extends ($Event) & ($IModBusEvent)>(arg0: $EventPriority$$Type, arg1: T): void
public "getModInfo"(): $IModInfo
public "getModId"(): string
get "namespace"(): string
get "eventBus"(): $IEventBus
get "modInfo"(): $IModInfo
get "modId"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModContainer$$Type = ($ModContainer);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModContainer_ = $ModContainer$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$MouseScrollingEvent" {
import {$InputEvent, $InputEvent$$Type} from "net.neoforged.neoforge.client.event.InputEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $InputEvent$MouseScrollingEvent extends $InputEvent implements $ICancellableEvent {

constructor(arg0: double, arg1: double, arg2: boolean, arg3: boolean, arg4: boolean, arg5: double, arg6: double)

public "isMiddleDown"(): boolean
public "isRightDown"(): boolean
public "getScrollDeltaX"(): double
public "getScrollDeltaY"(): double
public "getMouseY"(): double
public "getMouseX"(): double
public "isLeftDown"(): boolean
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "middleDown"(): boolean
get "rightDown"(): boolean
get "scrollDeltaX"(): double
get "scrollDeltaY"(): double
get "mouseY"(): double
get "mouseX"(): double
get "leftDown"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$MouseScrollingEvent$$Type = ($InputEvent$MouseScrollingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$MouseScrollingEvent_ = $InputEvent$MouseScrollingEvent$$Type;
}}
declare module "net.neoforged.neoforge.network.connection.ConnectionType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $ConnectionType extends $Enum<($ConnectionType)> {
static readonly "OTHER": $ConnectionType
static readonly "NEOFORGE": $ConnectionType


public static "values"(): ($ConnectionType)[]
public static "valueOf"(arg0: string): $ConnectionType
public "isOther"(): boolean
public "isNeoForge"(): boolean
get "other"(): boolean
get "neoForge"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConnectionType$$Type = (("neoforge") | ("other"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConnectionType_ = $ConnectionType$$Type;
}}
declare module "net.neoforged.neoforge.event.level.PistonEvent$Post" {
import {$PistonEvent, $PistonEvent$$Type} from "net.neoforged.neoforge.event.level.PistonEvent"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$PistonEvent$PistonMoveType, $PistonEvent$PistonMoveType$$Type} from "net.neoforged.neoforge.event.level.PistonEvent$PistonMoveType"

export class $PistonEvent$Post extends $PistonEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $PistonEvent$PistonMoveType$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PistonEvent$Post$$Type = ($PistonEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PistonEvent$Post_ = $PistonEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$BackgroundRendered" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

/**
 * 
 * @deprecated
 */
export class $ScreenEvent$BackgroundRendered extends $ScreenEvent {

constructor(arg0: $Screen$$Type, arg1: $GuiGraphics$$Type)

public "getGuiGraphics"(): $GuiGraphics
get "guiGraphics"(): $GuiGraphics
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$BackgroundRendered$$Type = ($ScreenEvent$BackgroundRendered);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$BackgroundRendered_ = $ScreenEvent$BackgroundRendered$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.DataMapType" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$DataMapType$Builder, $DataMapType$Builder$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType$Builder"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export class $DataMapType<R, T> {


public static "builder"<T, R>(arg0: $ResourceLocation$$Type, arg1: $ResourceKey$$Type<($Registry<(R)>)>, arg2: $Codec$$Type<(T)>): $DataMapType$Builder<(T), (R)>
public "id"(): $ResourceLocation
public "registryKey"(): $ResourceKey<($Registry<(R)>)>
public "codec"(): $Codec<(T)>
public "mandatorySync"(): boolean
public "networkCodec"(): $Codec<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataMapType$$Type<R, T> = ($DataMapType<(R), (T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataMapType_<R, T> = $DataMapType$$Type<(R), (T)>;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$SpawnPlacementCheck" {
import {$MobSpawnType, $MobSpawnType$$Type} from "net.minecraft.world.entity.MobSpawnType"
import {$ServerLevelAccessor, $ServerLevelAccessor$$Type} from "net.minecraft.world.level.ServerLevelAccessor"
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$MobSpawnEvent$SpawnPlacementCheck$Result, $MobSpawnEvent$SpawnPlacementCheck$Result$$Type} from "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$SpawnPlacementCheck$Result"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $MobSpawnEvent$SpawnPlacementCheck extends $Event {

constructor(arg0: $EntityType$$Type<(any)>, arg1: $ServerLevelAccessor$$Type, arg2: $MobSpawnType$$Type, arg3: $BlockPos$$Type, arg4: $RandomSource$$Type, arg5: boolean)

public "setResult"(arg0: $MobSpawnEvent$SpawnPlacementCheck$Result$$Type): void
public "getLevel"(): $ServerLevelAccessor
public "getResult"(): $MobSpawnEvent$SpawnPlacementCheck$Result
public "getSpawnType"(): $MobSpawnType
public "getEntityType"(): $EntityType<(any)>
public "getRandom"(): $RandomSource
public "getDefaultResult"(): boolean
public "getPos"(): $BlockPos
public "getPlacementCheckResult"(): boolean
set "result"(value: $MobSpawnEvent$SpawnPlacementCheck$Result$$Type)
get "level"(): $ServerLevelAccessor
get "result"(): $MobSpawnEvent$SpawnPlacementCheck$Result
get "spawnType"(): $MobSpawnType
get "entityType"(): $EntityType<(any)>
get "random"(): $RandomSource
get "defaultResult"(): boolean
get "pos"(): $BlockPos
get "placementCheckResult"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnEvent$SpawnPlacementCheck$$Type = ($MobSpawnEvent$SpawnPlacementCheck);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnEvent$SpawnPlacementCheck_ = $MobSpawnEvent$SpawnPlacementCheck$$Type;
}}
declare module "net.neoforged.neoforge.event.AddPackFindersEvent" {
import {$Pack$Position, $Pack$Position$$Type} from "net.minecraft.server.packs.repository.Pack$Position"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$PackType, $PackType$$Type} from "net.minecraft.server.packs.PackType"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PackSource, $PackSource$$Type} from "net.minecraft.server.packs.repository.PackSource"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$RepositorySource, $RepositorySource$$Type} from "net.minecraft.server.packs.repository.RepositorySource"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $AddPackFindersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $PackType$$Type, arg1: $Consumer$$Type<($RepositorySource)>, arg2: boolean)

public "isTrusted"(): boolean
public "getPackType"(): $PackType
public "addPackFinders"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type, arg2: $Component$$Type, arg3: $PackSource$$Type, arg4: boolean, arg5: $Pack$Position$$Type): void
public "addRepositorySource"(arg0: $RepositorySource$$Type): void
get "trusted"(): boolean
get "packType"(): $PackType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddPackFindersEvent$$Type = ($AddPackFindersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddPackFindersEvent_ = $AddPackFindersEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.data.ExistingFileHelper" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$File, $File$$Type} from "java.io.File"
import {$PackType, $PackType$$Type} from "net.minecraft.server.packs.PackType"
import {$List, $List$$Type} from "java.util.List"
import {$Set, $Set$$Type} from "java.util.Set"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$ExistingFileHelper$IResourceType, $ExistingFileHelper$IResourceType$$Type} from "net.neoforged.neoforge.common.data.ExistingFileHelper$IResourceType"
import {$Resource, $Resource$$Type} from "net.minecraft.server.packs.resources.Resource"

export class $ExistingFileHelper {

constructor(arg0: $Collection$$Type<($Path$$Type)>, arg1: $Set$$Type<(string)>, arg2: boolean, arg3: string, arg4: $File$$Type)

public "isEnabled"(): boolean
public "getResource"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type, arg2: string, arg3: string): $Resource
public "getResource"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type): $Resource
public "exists"(arg0: $ResourceLocation$$Type, arg1: $ExistingFileHelper$IResourceType$$Type): boolean
public "exists"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type): boolean
public "exists"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type, arg2: string, arg3: string): boolean
public "getResourceStack"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type): $List<($Resource)>
public "trackGenerated"(arg0: $ResourceLocation$$Type, arg1: $ExistingFileHelper$IResourceType$$Type): void
public "trackGenerated"(arg0: $ResourceLocation$$Type, arg1: $PackType$$Type, arg2: string, arg3: string): void
get "enabled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExistingFileHelper$$Type = ($ExistingFileHelper);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExistingFileHelper_ = $ExistingFileHelper$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$StartTracking" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent$StartTracking extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Entity$$Type)

public "getTarget"(): $Entity
public "getEntity"(): $Entity
get "target"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$StartTracking$$Type = ($PlayerEvent$StartTracking);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$StartTracking_ = $PlayerEvent$StartTracking$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IPacketFlowExtension" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$LogicalSide, $LogicalSide$$Type} from "net.neoforged.fml.LogicalSide"

export interface $IPacketFlowExtension {

 "self"(): $PacketFlow
 "isServerbound"(): boolean
 "isClientbound"(): boolean
 "getReceptionSide"(): $LogicalSide
get "serverbound"(): boolean
get "clientbound"(): boolean
get "receptionSide"(): $LogicalSide
}

export namespace $IPacketFlowExtension {
const probejs$$marker: never
}
export class $IPacketFlowExtension$$Static implements $IPacketFlowExtension {


 "self"(): $PacketFlow
 "isServerbound"(): boolean
 "isClientbound"(): boolean
 "getReceptionSide"(): $LogicalSide
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPacketFlowExtension$$Type = ($IPacketFlowExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPacketFlowExtension_ = $IPacketFlowExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityInvulnerabilityCheckEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityInvulnerabilityCheckEvent extends $EntityEvent {

constructor(arg0: $Entity$$Type, arg1: $DamageSource$$Type, arg2: boolean)

public "getSource"(): $DamageSource
public "isInvulnerable"(): boolean
public "setInvulnerable"(arg0: boolean): void
public "getOriginalInvulnerability"(): boolean
get "source"(): $DamageSource
get "invulnerable"(): boolean
set "invulnerable"(value: boolean)
get "originalInvulnerability"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityInvulnerabilityCheckEvent$$Type = ($EntityInvulnerabilityCheckEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityInvulnerabilityCheckEvent_ = $EntityInvulnerabilityCheckEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderTooltipEvent$Color" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$List, $List$$Type} from "java.util.List"
import {$RenderTooltipEvent, $RenderTooltipEvent$$Type} from "net.neoforged.neoforge.client.event.RenderTooltipEvent"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"
import {$ClientTooltipComponent, $ClientTooltipComponent$$Type} from "net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent"

export class $RenderTooltipEvent$Color extends $RenderTooltipEvent {

constructor(arg0: $ItemStack$$Type, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer, arg4: $Font$$Type, arg5: integer, arg6: integer, arg7: integer, arg8: $List$$Type<($ClientTooltipComponent$$Type)>)

public "setBackgroundEnd"(arg0: integer): void
public "setBackgroundStart"(arg0: integer): void
public "setBorderStart"(arg0: integer): void
public "setBorderEnd"(arg0: integer): void
public "setBackground"(arg0: integer): void
public "getBackgroundStart"(): integer
public "getBackgroundEnd"(): integer
public "getBorderStart"(): integer
public "getBorderEnd"(): integer
public "getOriginalBackgroundEnd"(): integer
public "getOriginalBackgroundStart"(): integer
public "getOriginalBorderStart"(): integer
public "getOriginalBorderEnd"(): integer
set "backgroundEnd"(value: integer)
set "backgroundStart"(value: integer)
set "borderStart"(value: integer)
set "borderEnd"(value: integer)
set "background"(value: integer)
get "backgroundStart"(): integer
get "backgroundEnd"(): integer
get "borderStart"(): integer
get "borderEnd"(): integer
get "originalBackgroundEnd"(): integer
get "originalBackgroundStart"(): integer
get "originalBorderStart"(): integer
get "originalBorderEnd"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderTooltipEvent$Color$$Type = ($RenderTooltipEvent$Color);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderTooltipEvent$Color_ = $RenderTooltipEvent$Color$$Type;
}}
declare module "net.neoforged.neoforge.client.entity.animation.AnimationTarget" {
import {$AnimationKeyframeTarget, $AnimationKeyframeTarget$$Type} from "net.neoforged.neoforge.client.entity.animation.AnimationKeyframeTarget"
import {$AnimationChannel$Target, $AnimationChannel$Target$$Type} from "net.minecraft.client.animation.AnimationChannel$Target"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $AnimationTarget extends $Record {
static readonly "ROTATION": $AnimationTarget
static readonly "POSITION": $AnimationTarget
static readonly "SCALE": $AnimationTarget

constructor(channelTarget: $AnimationChannel$Target$$Type, keyframeTarget: $AnimationKeyframeTarget$$Type, inverseKeyframeTarget: $AnimationKeyframeTarget$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "channelTarget"(): $AnimationChannel$Target
public "keyframeTarget"(): $AnimationKeyframeTarget
public "inverseKeyframeTarget"(): $AnimationKeyframeTarget
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnimationTarget$$Type = ({"keyframeTarget"?: $AnimationKeyframeTarget$$Type, "channelTarget"?: $AnimationChannel$Target$$Type, "inverseKeyframeTarget"?: $AnimationKeyframeTarget$$Type}) | ([keyframeTarget?: $AnimationKeyframeTarget$$Type, channelTarget?: $AnimationChannel$Target$$Type, inverseKeyframeTarget?: $AnimationKeyframeTarget$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnimationTarget_ = $AnimationTarget$$Type;
}}
declare module "net.neoforged.neoforge.attachment.IAttachmentCopyHandler" {
import {$IAttachmentHolder, $IAttachmentHolder$$Type} from "net.neoforged.neoforge.attachment.IAttachmentHolder"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $IAttachmentCopyHandler<T> {

 "copy"(arg0: T, arg1: $IAttachmentHolder$$Type, arg2: $HolderLookup$Provider$$Type): T

(arg0: T, arg1: $IAttachmentHolder, arg2: $HolderLookup$Provider): T
}

export namespace $IAttachmentCopyHandler {
const probejs$$marker: never
}
export class $IAttachmentCopyHandler$$Static<T> implements $IAttachmentCopyHandler {


 "copy"(arg0: T, arg1: $IAttachmentHolder$$Type, arg2: $HolderLookup$Provider$$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAttachmentCopyHandler$$Type<T> = ((arg0: T, arg1: $IAttachmentHolder, arg2: $HolderLookup$Provider) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAttachmentCopyHandler_<T> = $IAttachmentCopyHandler$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.brewing.PotionBrewEvent$Post" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$PotionBrewEvent, $PotionBrewEvent$$Type} from "net.neoforged.neoforge.event.brewing.PotionBrewEvent"
import {$NonNullList, $NonNullList$$Type} from "net.minecraft.core.NonNullList"

export class $PotionBrewEvent$Post extends $PotionBrewEvent {

constructor(arg0: $NonNullList$$Type<($ItemStack$$Type)>)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PotionBrewEvent$Post$$Type = ($PotionBrewEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PotionBrewEvent$Post_ = $PotionBrewEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContext" {
import {$PermissionDynamicContextKey, $PermissionDynamicContextKey$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContextKey"

export class $PermissionDynamicContext<T> {


public "equals"(arg0: any): boolean
public "hashCode"(): integer
public "getValue"(): T
public "getDynamic"(): $PermissionDynamicContextKey<(T)>
public "getSerializedValue"(): string
get "value"(): T
get "dynamic"(): $PermissionDynamicContextKey<(T)>
get "serializedValue"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionDynamicContext$$Type<T> = ($PermissionDynamicContext<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionDynamicContext_<T> = $PermissionDynamicContext$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.registries.holdersets.NotHolderSet$Type" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ICustomHolderSet, $ICustomHolderSet$$Type} from "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$HolderSetType, $HolderSetType$$Type} from "net.neoforged.neoforge.registries.holdersets.HolderSetType"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $NotHolderSet$Type implements $HolderSetType {

constructor()

public "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
public "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NotHolderSet$Type$$Type = ($NotHolderSet$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NotHolderSet$Type_ = $NotHolderSet$Type$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderFrameEvent$Pre" {
import {$RenderFrameEvent, $RenderFrameEvent$$Type} from "net.neoforged.neoforge.client.event.RenderFrameEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderFrameEvent$Pre extends $RenderFrameEvent {

constructor(arg0: $DeltaTracker$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderFrameEvent$Pre$$Type = ($RenderFrameEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderFrameEvent$Pre_ = $RenderFrameEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.registries.datamaps.IWithData" {
import {$DataMapType, $DataMapType$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType"

export interface $IWithData<R> {

 "getData"<T>(arg0: $DataMapType$$Type<(R), (T)>): T
}

export namespace $IWithData {
const probejs$$marker: never
}
export class $IWithData$$Static<R> implements $IWithData {


 "getData"<T>(arg0: $DataMapType$$Type<(R), (T)>): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IWithData$$Type<R> = ($IWithData<(R)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IWithData_<R> = $IWithData$$Type<(R)>;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyPressed$Pre" {
import {$ScreenEvent$KeyPressed, $ScreenEvent$KeyPressed$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyPressed"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$KeyPressed$Pre extends $ScreenEvent$KeyPressed implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyPressed$Pre$$Type = ($ScreenEvent$KeyPressed$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyPressed$Pre_ = $ScreenEvent$KeyPressed$Pre$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.SoundEngineLoadEvent" {
import {$SoundEvent, $SoundEvent$$Type} from "net.neoforged.neoforge.client.event.sound.SoundEvent"
import {$SoundEngine, $SoundEngine$$Type} from "net.minecraft.client.sounds.SoundEngine"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $SoundEngineLoadEvent extends $SoundEvent implements $IModBusEvent {

constructor(arg0: $SoundEngine$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SoundEngineLoadEvent$$Type = ($SoundEngineLoadEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SoundEngineLoadEvent_ = $SoundEngineLoadEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingHealEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingHealEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: float)

public "getAmount"(): float
public "setAmount"(arg0: float): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "amount"(): float
set "amount"(value: float)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingHealEvent$$Type = ($LivingHealEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingHealEvent_ = $LivingHealEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientTickEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ClientTickEvent extends $Event {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientTickEvent$$Type = ($ClientTickEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientTickEvent_ = $ClientTickEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.BuildCreativeModeTabContentsEvent" {
import {$FeatureFlagSet, $FeatureFlagSet$$Type} from "net.minecraft.world.flag.FeatureFlagSet"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$InsertableLinkedOpenCustomHashSet, $InsertableLinkedOpenCustomHashSet$$Type} from "net.neoforged.neoforge.common.util.InsertableLinkedOpenCustomHashSet"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$CreativeModeTab$ItemDisplayParameters, $CreativeModeTab$ItemDisplayParameters$$Type} from "net.minecraft.world.item.CreativeModeTab$ItemDisplayParameters"
import {$CreativeModeTab, $CreativeModeTab$$Type} from "net.minecraft.world.item.CreativeModeTab"
import {$CreativeModeTab$Output, $CreativeModeTab$Output$$Type} from "net.minecraft.world.item.CreativeModeTab$Output"
import {$ObjectSortedSet, $ObjectSortedSet$$Type} from "it.unimi.dsi.fastutil.objects.ObjectSortedSet"
import {$ItemLike, $ItemLike$$Type} from "net.minecraft.world.level.ItemLike"
import {$CreativeModeTab$TabVisibility, $CreativeModeTab$TabVisibility$$Type} from "net.minecraft.world.item.CreativeModeTab$TabVisibility"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $BuildCreativeModeTabContentsEvent extends $Event implements $IModBusEvent, $CreativeModeTab$Output {

constructor(arg0: $CreativeModeTab$$Type, arg1: $ResourceKey$$Type<($CreativeModeTab)>, arg2: $CreativeModeTab$ItemDisplayParameters$$Type, arg3: $InsertableLinkedOpenCustomHashSet$$Type<($ItemStack$$Type)>, arg4: $InsertableLinkedOpenCustomHashSet$$Type<($ItemStack$$Type)>)

public "remove"(arg0: $ItemStack$$Type, arg1: $CreativeModeTab$TabVisibility$$Type): void
public "accept"(arg0: $ItemStack$$Type, arg1: $CreativeModeTab$TabVisibility$$Type): void
public "getParameters"(): $CreativeModeTab$ItemDisplayParameters
public "getFlags"(): $FeatureFlagSet
public "insertBefore"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: $CreativeModeTab$TabVisibility$$Type): void
public "hasPermissions"(): boolean
public "getTab"(): $CreativeModeTab
public "getTabKey"(): $ResourceKey<($CreativeModeTab)>
public "insertAfter"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: $CreativeModeTab$TabVisibility$$Type): void
public "getParentEntries"(): $ObjectSortedSet<($ItemStack)>
public "insertFirst"(arg0: $ItemStack$$Type, arg1: $CreativeModeTab$TabVisibility$$Type): void
public "getSearchEntries"(): $ObjectSortedSet<($ItemStack)>
public "acceptAll"(arg0: $Collection$$Type<($ItemStack$$Type)>): void
public "acceptAll"(arg0: $Collection$$Type<($ItemStack$$Type)>, arg1: $CreativeModeTab$TabVisibility$$Type): void
public "accept"(arg0: $ItemLike$$Type): void
public "accept"(arg0: $ItemStack$$Type): void
public "accept"(arg0: $ItemLike$$Type, arg1: $CreativeModeTab$TabVisibility$$Type): void
get "parameters"(): $CreativeModeTab$ItemDisplayParameters
get "flags"(): $FeatureFlagSet
get "tab"(): $CreativeModeTab
get "tabKey"(): $ResourceKey<($CreativeModeTab)>
get "parentEntries"(): $ObjectSortedSet<($ItemStack)>
get "searchEntries"(): $ObjectSortedSet<($ItemStack)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BuildCreativeModeTabContentsEvent$$Type = ($BuildCreativeModeTabContentsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BuildCreativeModeTabContentsEvent_ = $BuildCreativeModeTabContentsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$PlayerLoggedInEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$PlayerLoggedInEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $LivingEntity
get "entity"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$PlayerLoggedInEvent$$Type = ($PlayerEvent$PlayerLoggedInEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$PlayerLoggedInEvent_ = $PlayerEvent$PlayerLoggedInEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Render$Post" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$Render, $ScreenEvent$Render$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$Render"

export class $ScreenEvent$Render$Post extends $ScreenEvent$Render {

constructor(arg0: $Screen$$Type, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer, arg4: float)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Render$Post$$Type = ($ScreenEvent$Render$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Render$Post_ = $ScreenEvent$Render$Post$$Type;
}}
declare module "net.neoforged.neoforge.common.data.ExistingFileHelper$IResourceType" {
import {$PackType, $PackType$$Type} from "net.minecraft.server.packs.PackType"

export interface $ExistingFileHelper$IResourceType {

 "getPrefix"(): string
 "getSuffix"(): string
 "getPackType"(): $PackType
get "prefix"(): string
get "suffix"(): string
get "packType"(): $PackType
}

export namespace $ExistingFileHelper$IResourceType {
const probejs$$marker: never
}
export class $ExistingFileHelper$IResourceType$$Static implements $ExistingFileHelper$IResourceType {


 "getPrefix"(): string
 "getSuffix"(): string
 "getPackType"(): $PackType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExistingFileHelper$IResourceType$$Type = ($ExistingFileHelper$IResourceType);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExistingFileHelper$IResourceType_ = $ExistingFileHelper$IResourceType$$Type;
}}
declare module "net.neoforged.neoforge.client.model.data.ModelData$Builder" {
import {$ModelProperty, $ModelProperty$$Type} from "net.neoforged.neoforge.client.model.data.ModelProperty"
import {$ModelData, $ModelData$$Type} from "net.neoforged.neoforge.client.model.data.ModelData"

export class $ModelData$Builder {


public "with"<T>(arg0: $ModelProperty$$Type<(T)>, arg1: T): $ModelData$Builder
public "build"(): $ModelData
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelData$Builder$$Type = ($ModelData$Builder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelData$Builder_ = $ModelData$Builder$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseDragged$Pre" {
import {$ScreenEvent$MouseDragged, $ScreenEvent$MouseDragged$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseDragged"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$MouseDragged$Pre extends $ScreenEvent$MouseDragged implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer, arg4: double, arg5: double)

public "getMouseY"(): double
public "getMouseX"(): double
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "mouseY"(): double
get "mouseX"(): double
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseDragged$Pre$$Type = ($ScreenEvent$MouseDragged$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseDragged$Pre_ = $ScreenEvent$MouseDragged$Pre$$Type;
}}
declare module "net.neoforged.neoforge.entity.XpOrbTargetingEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ExperienceOrb, $ExperienceOrb$$Type} from "net.minecraft.world.entity.ExperienceOrb"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $XpOrbTargetingEvent extends $Event {

constructor(arg0: $ExperienceOrb$$Type, arg1: double)

public "getScanDistance"(): double
public "setFollowingPlayer"(arg0: $Player$$Type): void
public "getXpOrb"(): $ExperienceOrb
public "getFollowingPlayer"(): $Player
get "scanDistance"(): double
set "followingPlayer"(value: $Player$$Type)
get "xpOrb"(): $ExperienceOrb
get "followingPlayer"(): $Player
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $XpOrbTargetingEvent$$Type = ($XpOrbTargetingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $XpOrbTargetingEvent_ = $XpOrbTargetingEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$ItemCraftedEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Container, $Container$$Type} from "net.minecraft.world.Container"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$ItemCraftedEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Container$$Type)

public "getEntity"(): $LivingEntity
public "getInventory"(): $Container
public "getCrafting"(): $ItemStack
get "entity"(): $LivingEntity
get "inventory"(): $Container
get "crafting"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$ItemCraftedEvent$$Type = ($PlayerEvent$ItemCraftedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$ItemCraftedEvent_ = $PlayerEvent$ItemCraftedEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.locating.ModFileInfoParser" {
import {$IModFileInfo, $IModFileInfo$$Type} from "net.neoforged.neoforgespi.language.IModFileInfo"
import {$IModFile, $IModFile$$Type} from "net.neoforged.neoforgespi.locating.IModFile"

export interface $ModFileInfoParser {

 "build"(arg0: $IModFile$$Type): $IModFileInfo

(arg0: $IModFile): $IModFileInfo$$Type
}

export namespace $ModFileInfoParser {
const probejs$$marker: never
}
export class $ModFileInfoParser$$Static implements $ModFileInfoParser {


 "build"(arg0: $IModFile$$Type): $IModFileInfo
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFileInfoParser$$Type = ((arg0: $IModFile) => $IModFileInfo$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFileInfoParser_ = $ModFileInfoParser$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.PlayStreamingSourceEvent" {
import {$SoundEngine, $SoundEngine$$Type} from "net.minecraft.client.sounds.SoundEngine"
import {$SoundInstance, $SoundInstance$$Type} from "net.minecraft.client.resources.sounds.SoundInstance"
import {$Channel, $Channel$$Type} from "com.mojang.blaze3d.audio.Channel"
import {$SoundEvent$SoundSourceEvent, $SoundEvent$SoundSourceEvent$$Type} from "net.neoforged.neoforge.client.event.sound.SoundEvent$SoundSourceEvent"

export class $PlayStreamingSourceEvent extends $SoundEvent$SoundSourceEvent {

constructor(arg0: $SoundEngine$$Type, arg1: $SoundInstance$$Type, arg2: $Channel$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayStreamingSourceEvent$$Type = ($PlayStreamingSourceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayStreamingSourceEvent_ = $PlayStreamingSourceEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderTooltipEvent$Pre" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$RenderTooltipEvent, $RenderTooltipEvent$$Type} from "net.neoforged.neoforge.client.event.RenderTooltipEvent"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"
import {$ClientTooltipPositioner, $ClientTooltipPositioner$$Type} from "net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipPositioner"
import {$ClientTooltipComponent, $ClientTooltipComponent$$Type} from "net.minecraft.client.gui.screens.inventory.tooltip.ClientTooltipComponent"

export class $RenderTooltipEvent$Pre extends $RenderTooltipEvent implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: $Font$$Type, arg7: $List$$Type<($ClientTooltipComponent$$Type)>, arg8: $ClientTooltipPositioner$$Type)

public "setFont"(arg0: $Font$$Type): void
public "getScreenHeight"(): integer
public "getScreenWidth"(): integer
public "setX"(arg0: integer): void
public "setY"(arg0: integer): void
public "getTooltipPositioner"(): $ClientTooltipPositioner
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "font"(value: $Font$$Type)
get "screenHeight"(): integer
get "screenWidth"(): integer
set "x"(value: integer)
set "y"(value: integer)
get "tooltipPositioner"(): $ClientTooltipPositioner
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderTooltipEvent$Pre$$Type = ($RenderTooltipEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderTooltipEvent$Pre_ = $RenderTooltipEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingFallEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingFallEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: float, arg2: float)

public "getDamageMultiplier"(): float
public "setDamageMultiplier"(arg0: float): void
public "setDistance"(arg0: float): void
public "getDistance"(): float
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "damageMultiplier"(): float
set "damageMultiplier"(value: float)
set "distance"(value: float)
get "distance"(): float
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingFallEvent$$Type = ($LivingFallEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingFallEvent_ = $LivingFallEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IOwnedSpawner" {
import {$Either, $Either$$Type} from "com.mojang.datafixers.util.Either"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"

export interface $IOwnedSpawner {

 "getOwner"(): $Either<($BlockEntity), ($Entity)>

(): $Either$$Type<($BlockEntity$$Type), ($Entity$$Type)>
get "owner"(): $Either<($BlockEntity), ($Entity)>
}

export namespace $IOwnedSpawner {
const probejs$$marker: never
}
export class $IOwnedSpawner$$Static implements $IOwnedSpawner {


 "getOwner"(): $Either<($BlockEntity), ($Entity)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IOwnedSpawner$$Type = (() => $Either$$Type<($BlockEntity$$Type), ($Entity$$Type)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IOwnedSpawner_ = $IOwnedSpawner$$Type;
}}
declare module "net.neoforged.neoforge.common.crafting.ICustomIngredient" {
import {$IngredientType, $IngredientType$$Type} from "net.neoforged.neoforge.common.crafting.IngredientType"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Ingredient, $Ingredient$$Type} from "net.minecraft.world.item.crafting.Ingredient"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"

export interface $ICustomIngredient {

 "isSimple"(): boolean
 "test"(arg0: $ItemStack$$Type): boolean
 "getType"(): $IngredientType<(any)>
 "toVanilla"(): $Ingredient
 "getItems"(): $Stream<($ItemStack)>
get "simple"(): boolean
get "type"(): $IngredientType<(any)>
get "items"(): $Stream<($ItemStack)>
}

export namespace $ICustomIngredient {
const probejs$$marker: never
}
export class $ICustomIngredient$$Static implements $ICustomIngredient {


 "isSimple"(): boolean
 "test"(arg0: $ItemStack$$Type): boolean
 "getType"(): $IngredientType<(any)>
 "toVanilla"(): $Ingredient
 "getItems"(): $Stream<($ItemStack)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICustomIngredient$$Type = ($ICustomIngredient);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICustomIngredient_ = $ICustomIngredient$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterMenuScreensEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$MenuType, $MenuType$$Type} from "net.minecraft.world.inventory.MenuType"
import {$MenuAccess, $MenuAccess$$Type} from "net.minecraft.client.gui.screens.inventory.MenuAccess"
import {$MenuScreens$ScreenConstructor, $MenuScreens$ScreenConstructor$$Type} from "net.minecraft.client.gui.screens.MenuScreens$ScreenConstructor"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterMenuScreensEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($MenuType$$Type<(any)>), ($MenuScreens$ScreenConstructor$$Type<(any), (any)>)>)

public "register"<M extends $AbstractContainerMenu, U extends ($Screen) & ($MenuAccess<(M)>)>(arg0: $MenuType$$Type<(M)>, arg1: $MenuScreens$ScreenConstructor$$Type<(M), (U)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterMenuScreensEvent$$Type = ($RegisterMenuScreensEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterMenuScreensEvent_ = $RegisterMenuScreensEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.brewing.RegisterBrewingRecipesEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PotionBrewing$Builder, $PotionBrewing$Builder$$Type} from "net.minecraft.world.item.alchemy.PotionBrewing$Builder"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $RegisterBrewingRecipesEvent extends $Event {

constructor(arg0: $PotionBrewing$Builder$$Type, arg1: $RegistryAccess$$Type)

public "getBuilder"(): $PotionBrewing$Builder
public "getRegistryAccess"(): $RegistryAccess
get "builder"(): $PotionBrewing$Builder
get "registryAccess"(): $RegistryAccess
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterBrewingRecipesEvent$$Type = ($RegisterBrewingRecipesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterBrewingRecipesEvent_ = $RegisterBrewingRecipesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$MouseButton$Post" {
import {$InputEvent$MouseButton, $InputEvent$MouseButton$$Type} from "net.neoforged.neoforge.client.event.InputEvent$MouseButton"

export class $InputEvent$MouseButton$Post extends $InputEvent$MouseButton {

constructor(arg0: integer, arg1: integer, arg2: integer)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$MouseButton$Post$$Type = ($InputEvent$MouseButton$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$MouseButton$Post_ = $InputEvent$MouseButton$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterRecipeBookCategoriesEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$RecipeHolder, $RecipeHolder$$Type} from "net.minecraft.world.item.crafting.RecipeHolder"
import {$RecipeBookType, $RecipeBookType$$Type} from "net.minecraft.world.inventory.RecipeBookType"
import {$List, $List$$Type} from "java.util.List"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RecipeType, $RecipeType$$Type} from "net.minecraft.world.item.crafting.RecipeType"
import {$ImmutableList, $ImmutableList$$Type} from "com.google.common.collect.ImmutableList"
import {$RecipeBookCategories, $RecipeBookCategories$$Type} from "net.minecraft.client.RecipeBookCategories"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterRecipeBookCategoriesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($RecipeBookCategories$$Type), ($ImmutableList$$Type<($RecipeBookCategories$$Type)>)>, arg1: $Map$$Type<($RecipeBookType$$Type), ($ImmutableList$$Type<($RecipeBookCategories$$Type)>)>, arg2: $Map$$Type<($RecipeType$$Type<(any)>), ($Function$$Type<($RecipeHolder$$Type<(any)>), ($RecipeBookCategories$$Type)>)>)

public "registerRecipeCategoryFinder"(arg0: $RecipeType$$Type<(any)>, arg1: $Function$$Type<($RecipeHolder<(any)>), ($RecipeBookCategories$$Type)>): void
public "registerBookCategories"(arg0: $RecipeBookType$$Type, arg1: $List$$Type<($RecipeBookCategories$$Type)>): void
public "registerAggregateCategory"(arg0: $RecipeBookCategories$$Type, arg1: $List$$Type<($RecipeBookCategories$$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterRecipeBookCategoriesEvent$$Type = ($RegisterRecipeBookCategoriesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterRecipeBookCategoriesEvent_ = $RegisterRecipeBookCategoriesEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$MouseButton" {
import {$InputEvent, $InputEvent$$Type} from "net.neoforged.neoforge.client.event.InputEvent"

export class $InputEvent$MouseButton extends $InputEvent {


public "getModifiers"(): integer
public "getAction"(): integer
public "getButton"(): integer
get "modifiers"(): integer
get "action"(): integer
get "button"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$MouseButton$$Type = ($InputEvent$MouseButton);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$MouseButton_ = $InputEvent$MouseButton$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ChunkWatchEvent$Watch" {
import {$ChunkWatchEvent, $ChunkWatchEvent$$Type} from "net.neoforged.neoforge.event.level.ChunkWatchEvent"
import {$LevelChunk, $LevelChunk$$Type} from "net.minecraft.world.level.chunk.LevelChunk"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export class $ChunkWatchEvent$Watch extends $ChunkWatchEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $LevelChunk$$Type, arg2: $ServerLevel$$Type)

public "getChunk"(): $LevelChunk
get "chunk"(): $LevelChunk
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkWatchEvent$Watch$$Type = ($ChunkWatchEvent$Watch);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkWatchEvent$Watch_ = $ChunkWatchEvent$Watch$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterPresetEditorsEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PresetEditor, $PresetEditor$$Type} from "net.minecraft.client.gui.screens.worldselection.PresetEditor"
import {$WorldPreset, $WorldPreset$$Type} from "net.minecraft.world.level.levelgen.presets.WorldPreset"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterPresetEditorsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceKey$$Type<($WorldPreset$$Type)>), ($PresetEditor$$Type)>)

public "register"(arg0: $ResourceKey$$Type<($WorldPreset)>, arg1: $PresetEditor$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterPresetEditorsEvent$$Type = ($RegisterPresetEditorsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterPresetEditorsEvent_ = $RegisterPresetEditorsEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.BiomeSpecialEffectsBuilder" {
import {$AmbientMoodSettings, $AmbientMoodSettings$$Type} from "net.minecraft.world.level.biome.AmbientMoodSettings"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$BiomeSpecialEffects$GrassColorModifier, $BiomeSpecialEffects$GrassColorModifier$$Type} from "net.minecraft.world.level.biome.BiomeSpecialEffects$GrassColorModifier"
import {$BiomeSpecialEffects$Builder, $BiomeSpecialEffects$Builder$$Type} from "net.minecraft.world.level.biome.BiomeSpecialEffects$Builder"
import {$AmbientParticleSettings, $AmbientParticleSettings$$Type} from "net.minecraft.world.level.biome.AmbientParticleSettings"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$AmbientAdditionsSettings, $AmbientAdditionsSettings$$Type} from "net.minecraft.world.level.biome.AmbientAdditionsSettings"
import {$Music, $Music$$Type} from "net.minecraft.sounds.Music"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$BiomeSpecialEffects, $BiomeSpecialEffects$$Type} from "net.minecraft.world.level.biome.BiomeSpecialEffects"

export class $BiomeSpecialEffectsBuilder extends $BiomeSpecialEffects$Builder {


public static "copyOf"(arg0: $BiomeSpecialEffects$$Type): $BiomeSpecialEffectsBuilder
public static "create"(arg0: integer, arg1: integer, arg2: integer, arg3: integer): $BiomeSpecialEffectsBuilder
public "getFoliageColorOverride"(): $Optional<(integer)>
public "getGrassColorOverride"(): $Optional<(integer)>
public "getGrassColorModifier"(): $BiomeSpecialEffects$GrassColorModifier
public "waterColor"(): integer
public "getFogColor"(): integer
public "getWaterFogColor"(): integer
public "getSkyColor"(): integer
public "getAmbientParticle"(): $Optional<($AmbientParticleSettings)>
public "getBackgroundMusic"(): $Optional<($Music)>
public "getAmbientMoodSound"(): $Optional<($AmbientMoodSettings)>
public "getAmbientLoopSound"(): $Optional<($Holder<($SoundEvent)>)>
public "getAmbientAdditionsSound"(): $Optional<($AmbientAdditionsSettings)>
get "foliageColorOverride"(): $Optional<(integer)>
get "grassColorOverride"(): $Optional<(integer)>
get "grassColorModifier"(): $BiomeSpecialEffects$GrassColorModifier
get "fogColor"(): integer
get "waterFogColor"(): integer
get "skyColor"(): integer
get "ambientParticle"(): $Optional<($AmbientParticleSettings)>
get "backgroundMusic"(): $Optional<($Music)>
get "ambientMoodSound"(): $Optional<($AmbientMoodSettings)>
get "ambientLoopSound"(): $Optional<($Holder<($SoundEvent)>)>
get "ambientAdditionsSound"(): $Optional<($AmbientAdditionsSettings)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BiomeSpecialEffectsBuilder$$Type = ($BiomeSpecialEffectsBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BiomeSpecialEffectsBuilder_ = $BiomeSpecialEffectsBuilder$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IAbstractWidgetExtension" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IAbstractWidgetExtension {

 "onClick"(arg0: double, arg1: double, arg2: integer): void
}

export namespace $IAbstractWidgetExtension {
const probejs$$marker: never
}
export class $IAbstractWidgetExtension$$Static implements $IAbstractWidgetExtension {


 "onClick"(arg0: double, arg1: double, arg2: integer): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAbstractWidgetExtension$$Type = ($IAbstractWidgetExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAbstractWidgetExtension_ = $IAbstractWidgetExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderNameTagEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$EntityRenderer, $EntityRenderer$$Type} from "net.minecraft.client.renderer.entity.EntityRenderer"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"

export class $RenderNameTagEvent extends $EntityEvent {

constructor(arg0: $Entity$$Type, arg1: $Component$$Type, arg2: $EntityRenderer$$Type<(any)>, arg3: $PoseStack$$Type, arg4: $MultiBufferSource$$Type, arg5: integer, arg6: float)

public "getContent"(): $Component
public "setContent"(arg0: $Component$$Type): void
public "getPackedLight"(): integer
public "canRender"(): $TriState
public "getPoseStack"(): $PoseStack
public "getPartialTick"(): float
public "getMultiBufferSource"(): $MultiBufferSource
public "getEntityRenderer"(): $EntityRenderer<(any)>
public "getOriginalContent"(): $Component
public "setCanRender"(arg0: $TriState$$Type): void
get "content"(): $Component
set "content"(value: $Component$$Type)
get "packedLight"(): integer
get "poseStack"(): $PoseStack
get "partialTick"(): float
get "multiBufferSource"(): $MultiBufferSource
get "entityRenderer"(): $EntityRenderer<(any)>
get "originalContent"(): $Component
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderNameTagEvent$$Type = ($RenderNameTagEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderNameTagEvent_ = $RenderNameTagEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IMenuProviderExtension" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IMenuProviderExtension {

 "shouldTriggerClientSideContainerClosingOnOpen"(): boolean
}

export namespace $IMenuProviderExtension {
const probejs$$marker: never
}
export class $IMenuProviderExtension$$Static implements $IMenuProviderExtension {


 "shouldTriggerClientSideContainerClosingOnOpen"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMenuProviderExtension$$Type = ($IMenuProviderExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMenuProviderExtension_ = $IMenuProviderExtension$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModInfo$DependencySide" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$Dist, $Dist$$Type} from "net.neoforged.api.distmarker.Dist"

export class $IModInfo$DependencySide extends $Enum<($IModInfo$DependencySide)> {
static readonly "SERVER": $IModInfo$DependencySide
static readonly "CLIENT": $IModInfo$DependencySide
static readonly "BOTH": $IModInfo$DependencySide


public static "values"(): ($IModInfo$DependencySide)[]
public static "valueOf"(arg0: string): $IModInfo$DependencySide
public "isContained"(arg0: $Dist$$Type): boolean
public "isCorrectSide"(): boolean
get "correctSide"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModInfo$DependencySide$$Type = (("client") | ("server") | ("both"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModInfo$DependencySide_ = $IModInfo$DependencySide$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IItemStackExtension" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$ItemAttributeModifiers, $ItemAttributeModifiers$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ItemAbility, $ItemAbility$$Type} from "net.neoforged.neoforge.common.ItemAbility"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$FoodProperties, $FoodProperties$$Type} from "net.minecraft.world.food.FoodProperties"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$ItemEnchantments, $ItemEnchantments$$Type} from "net.minecraft.world.item.enchantment.ItemEnchantments"
import {$EquipmentSlot, $EquipmentSlot$$Type} from "net.minecraft.world.entity.EquipmentSlot"
import {$ItemCapability, $ItemCapability$$Type} from "net.neoforged.neoforge.capabilities.ItemCapability"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$RecipeType, $RecipeType$$Type} from "net.minecraft.world.item.crafting.RecipeType"
import {$HolderLookup$RegistryLookup, $HolderLookup$RegistryLookup$$Type} from "net.minecraft.core.HolderLookup$RegistryLookup"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$EnderMan, $EnderMan$$Type} from "net.minecraft.world.entity.monster.EnderMan"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$Enchantment, $Enchantment$$Type} from "net.minecraft.world.item.enchantment.Enchantment"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$AABB, $AABB$$Type} from "net.minecraft.world.phys.AABB"

export interface $IItemStackExtension {

 "canEquip"(arg0: $EquipmentSlot$$Type, arg1: $LivingEntity$$Type): boolean
 "getCapability"<T, C>(arg0: $ItemCapability$$Type<(T), (C)>, arg1: C): T
 "getCapability"<T>(arg0: $ItemCapability$$Type<(T), (void)>): T
 "onAnimalArmorTick"(arg0: $Level$$Type, arg1: $Mob$$Type): void
 "shouldCauseBlockBreakReset"(arg0: $ItemStack$$Type): boolean
 "getEnchantmentLevel"(arg0: $Holder$$Type<($Enchantment)>): integer
 "getEnchantmentValue"(): integer
 "makesPiglinsNeutral"(arg0: $LivingEntity$$Type): boolean
 "canGrindstoneRepair"(): boolean
 "supportsEnchantment"(arg0: $Holder$$Type<($Enchantment)>): boolean
 "hasCraftingRemainingItem"(): boolean
 "getCraftingRemainingItem"(): $ItemStack
 "getEquipmentSlot"(): $EquipmentSlot
 "getSweepHitBox"(arg0: $Player$$Type, arg1: $Entity$$Type): $AABB
 "canDisableShield"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $LivingEntity$$Type): boolean
 "canElytraFly"(arg0: $LivingEntity$$Type): boolean
 "elytraFlightTick"(arg0: $LivingEntity$$Type, arg1: integer): boolean
/**
 * 
 * @deprecated
 */
 "onEntitySwing"(arg0: $LivingEntity$$Type): boolean
 "onEntitySwing"(arg0: $LivingEntity$$Type, arg1: $InteractionHand$$Type): boolean
 "onEntityItemUpdate"(arg0: $ItemEntity$$Type): boolean
 "getFoodProperties"(arg0: $LivingEntity$$Type): $FoodProperties
 "onDestroyed"(arg0: $ItemEntity$$Type, arg1: $DamageSource$$Type): void
 "onStopUsing"(arg0: $LivingEntity$$Type, arg1: integer): void
 "getEntityLifespan"(arg0: $Level$$Type): integer
 "getAttributeModifiers"(): $ItemAttributeModifiers
 "getBurnTime"(arg0: $RecipeType$$Type<(any)>): integer
 "doesSneakBypassUse"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type): boolean
 "isEnderMask"(arg0: $Player$$Type, arg1: $EnderMan$$Type): boolean
 "getAllEnchantments"(arg0: $HolderLookup$RegistryLookup$$Type<($Enchantment$$Type)>): $ItemEnchantments
 "onDroppedByPlayer"(arg0: $Player$$Type): boolean
 "isBookEnchantable"(arg0: $ItemStack$$Type): boolean
 "isPrimaryItemFor"(arg0: $Holder$$Type<($Enchantment)>): boolean
 "isRepairable"(): boolean
 "getXpRepairRatio"(): float
 "isPiglinCurrency"(): boolean
 "onItemUseFirst"(arg0: $UseOnContext$$Type): $InteractionResult
 "getHighlightTip"(arg0: $Component$$Type): $Component
 "isNotReplaceableByPickAction"(arg0: $Player$$Type, arg1: integer): boolean
 "canPerformAction"(arg0: $ItemAbility$$Type): boolean
 "canWalkOnPowderedSnow"(arg0: $LivingEntity$$Type): boolean
get "enchantmentValue"(): integer
get "craftingRemainingItem"(): $ItemStack
get "equipmentSlot"(): $EquipmentSlot
get "attributeModifiers"(): $ItemAttributeModifiers
get "repairable"(): boolean
get "xpRepairRatio"(): float
get "piglinCurrency"(): boolean
}

export namespace $IItemStackExtension {
const probejs$$marker: never
}
export class $IItemStackExtension$$Static implements $IItemStackExtension {


 "canEquip"(arg0: $EquipmentSlot$$Type, arg1: $LivingEntity$$Type): boolean
 "getCapability"<T, C>(arg0: $ItemCapability$$Type<(T), (C)>, arg1: C): T
 "getCapability"<T>(arg0: $ItemCapability$$Type<(T), (void)>): T
 "onAnimalArmorTick"(arg0: $Level$$Type, arg1: $Mob$$Type): void
 "shouldCauseBlockBreakReset"(arg0: $ItemStack$$Type): boolean
 "getEnchantmentLevel"(arg0: $Holder$$Type<($Enchantment)>): integer
 "getEnchantmentValue"(): integer
 "makesPiglinsNeutral"(arg0: $LivingEntity$$Type): boolean
 "canGrindstoneRepair"(): boolean
 "supportsEnchantment"(arg0: $Holder$$Type<($Enchantment)>): boolean
 "hasCraftingRemainingItem"(): boolean
 "getCraftingRemainingItem"(): $ItemStack
 "getEquipmentSlot"(): $EquipmentSlot
 "getSweepHitBox"(arg0: $Player$$Type, arg1: $Entity$$Type): $AABB
 "canDisableShield"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $LivingEntity$$Type): boolean
 "canElytraFly"(arg0: $LivingEntity$$Type): boolean
 "elytraFlightTick"(arg0: $LivingEntity$$Type, arg1: integer): boolean
/**
 * 
 * @deprecated
 */
 "onEntitySwing"(arg0: $LivingEntity$$Type): boolean
 "onEntitySwing"(arg0: $LivingEntity$$Type, arg1: $InteractionHand$$Type): boolean
 "onEntityItemUpdate"(arg0: $ItemEntity$$Type): boolean
 "getFoodProperties"(arg0: $LivingEntity$$Type): $FoodProperties
 "onDestroyed"(arg0: $ItemEntity$$Type, arg1: $DamageSource$$Type): void
 "onStopUsing"(arg0: $LivingEntity$$Type, arg1: integer): void
 "getEntityLifespan"(arg0: $Level$$Type): integer
 "getAttributeModifiers"(): $ItemAttributeModifiers
 "getBurnTime"(arg0: $RecipeType$$Type<(any)>): integer
 "doesSneakBypassUse"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type): boolean
 "isEnderMask"(arg0: $Player$$Type, arg1: $EnderMan$$Type): boolean
 "getAllEnchantments"(arg0: $HolderLookup$RegistryLookup$$Type<($Enchantment$$Type)>): $ItemEnchantments
 "onDroppedByPlayer"(arg0: $Player$$Type): boolean
 "isBookEnchantable"(arg0: $ItemStack$$Type): boolean
 "isPrimaryItemFor"(arg0: $Holder$$Type<($Enchantment)>): boolean
 "isRepairable"(): boolean
 "getXpRepairRatio"(): float
 "isPiglinCurrency"(): boolean
 "onItemUseFirst"(arg0: $UseOnContext$$Type): $InteractionResult
 "getHighlightTip"(arg0: $Component$$Type): $Component
 "isNotReplaceableByPickAction"(arg0: $Player$$Type, arg1: integer): boolean
 "canPerformAction"(arg0: $ItemAbility$$Type): boolean
 "canWalkOnPowderedSnow"(arg0: $LivingEntity$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IItemStackExtension$$Type = ($IItemStackExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IItemStackExtension_ = $IItemStackExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent$Chat" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Window, $Window$$Type} from "com.mojang.blaze3d.platform.Window"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$CustomizeGuiOverlayEvent, $CustomizeGuiOverlayEvent$$Type} from "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent"

export class $CustomizeGuiOverlayEvent$Chat extends $CustomizeGuiOverlayEvent {

constructor(arg0: $Window$$Type, arg1: $GuiGraphics$$Type, arg2: $DeltaTracker$$Type, arg3: integer, arg4: integer)

public "getPosY"(): integer
public "getPosX"(): integer
public "setPosY"(arg0: integer): void
public "setPosX"(arg0: integer): void
get "posY"(): integer
get "posX"(): integer
set "posY"(value: integer)
set "posX"(value: integer)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CustomizeGuiOverlayEvent$Chat$$Type = ($CustomizeGuiOverlayEvent$Chat);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CustomizeGuiOverlayEvent$Chat_ = $CustomizeGuiOverlayEvent$Chat$$Type;
}}
declare module "net.neoforged.neoforge.common.damagesource.DamageContainer" {
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$LivingShieldBlockEvent, $LivingShieldBlockEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingShieldBlockEvent"
import {$IReductionFunction, $IReductionFunction$$Type} from "net.neoforged.neoforge.common.damagesource.IReductionFunction"
import {$DamageContainer$Reduction, $DamageContainer$Reduction$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer$Reduction"

export class $DamageContainer {

constructor(arg0: $DamageSource$$Type, arg1: float)

public "getSource"(): $DamageSource
public "setPostAttackInvulnerabilityTicks"(arg0: integer): void
public "setBlockedDamage"(arg0: $LivingShieldBlockEvent$$Type): void
public "getBlockedDamage"(): float
public "setNewDamage"(arg0: float): void
public "getReduction"(arg0: $DamageContainer$Reduction$$Type): float
public "getNewDamage"(): float
public "setReduction"(arg0: $DamageContainer$Reduction$$Type, arg1: float): void
public "getOriginalDamage"(): float
public "addModifier"(arg0: $DamageContainer$Reduction$$Type, arg1: $IReductionFunction$$Type): void
public "getShieldDamage"(): float
public "getPostAttackInvulnerabilityTicks"(): integer
get "source"(): $DamageSource
set "postAttackInvulnerabilityTicks"(value: integer)
set "blockedDamage"(value: $LivingShieldBlockEvent$$Type)
get "blockedDamage"(): float
set "newDamage"(value: float)
get "newDamage"(): float
get "originalDamage"(): float
get "shieldDamage"(): float
get "postAttackInvulnerabilityTicks"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DamageContainer$$Type = ($DamageContainer);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DamageContainer_ = $DamageContainer$$Type;
}}
declare module "net.neoforged.neoforge.client.event.AddAttributeTooltipsEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$AttributeTooltipContext, $AttributeTooltipContext$$Type} from "net.neoforged.neoforge.common.util.AttributeTooltipContext"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $AddAttributeTooltipsEvent extends $Event {

constructor(arg0: $ItemStack$$Type, arg1: $Consumer$$Type<($Component)>, arg2: $AttributeTooltipContext$$Type)

public "getContext"(): $AttributeTooltipContext
public "getStack"(): $ItemStack
public "shouldShow"(): boolean
public "addTooltipLines"(...arg0: ($Component$$Type)[]): void
get "context"(): $AttributeTooltipContext
get "stack"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddAttributeTooltipsEvent$$Type = ($AddAttributeTooltipsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddAttributeTooltipsEvent_ = $AddAttributeTooltipsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderArmEvent" {
import {$HumanoidArm, $HumanoidArm$$Type} from "net.minecraft.world.entity.HumanoidArm"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$AbstractClientPlayer, $AbstractClientPlayer$$Type} from "net.minecraft.client.player.AbstractClientPlayer"

export class $RenderArmEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $PoseStack$$Type, arg1: $MultiBufferSource$$Type, arg2: integer, arg3: $AbstractClientPlayer$$Type, arg4: $HumanoidArm$$Type)

public "getPackedLight"(): integer
public "getPoseStack"(): $PoseStack
public "getArm"(): $HumanoidArm
public "getPlayer"(): $AbstractClientPlayer
public "getMultiBufferSource"(): $MultiBufferSource
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "packedLight"(): integer
get "poseStack"(): $PoseStack
get "arm"(): $HumanoidArm
get "player"(): $AbstractClientPlayer
get "multiBufferSource"(): $MultiBufferSource
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderArmEvent$$Type = ($RenderArmEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderArmEvent_ = $RenderArmEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.block.CropGrowEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $CropGrowEvent extends $BlockEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CropGrowEvent$$Type = ($CropGrowEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CropGrowEvent_ = $CropGrowEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.BonemealEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BonemealEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $ItemStack$$Type)

public "getState"(): $BlockState
public "getStack"(): $ItemStack
public "getLevel"(): $Level
public "setCanceled"(arg0: boolean): void
public "setSuccessful"(arg0: boolean): void
public "getPos"(): $BlockPos
public "isValidBonemealTarget"(): boolean
public "getPlayer"(): $Player
public "isSuccessful"(): boolean
public "isCanceled"(): boolean
get "state"(): $BlockState
get "stack"(): $ItemStack
get "level"(): $Level
set "canceled"(value: boolean)
set "successful"(value: boolean)
get "pos"(): $BlockPos
get "validBonemealTarget"(): boolean
get "player"(): $Player
get "successful"(): boolean
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BonemealEvent$$Type = ($BonemealEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BonemealEvent_ = $BonemealEvent$$Type;
}}
declare module "net.neoforged.neoforge.attachment.IAttachmentHolder" {
import {$AttachmentType, $AttachmentType$$Type} from "net.neoforged.neoforge.attachment.AttachmentType"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"

export interface $IAttachmentHolder {

 "getData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
 "getData"<T>(arg0: $AttachmentType$$Type<(T)>): T
 "hasData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): boolean
 "hasData"(arg0: $AttachmentType$$Type<(any)>): boolean
 "removeData"<T>(arg0: $AttachmentType$$Type<(T)>): T
 "removeData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
 "setData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>, arg1: T): T
 "setData"<T>(arg0: $AttachmentType$$Type<(T)>, arg1: T): T
 "getExistingData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): $Optional<(T)>
 "getExistingData"<T>(arg0: $AttachmentType$$Type<(T)>): $Optional<(T)>
 "hasAttachments"(): boolean
}

export namespace $IAttachmentHolder {
const probejs$$marker: never
}
export class $IAttachmentHolder$$Static implements $IAttachmentHolder {


 "getData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
 "getData"<T>(arg0: $AttachmentType$$Type<(T)>): T
 "hasData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): boolean
 "hasData"(arg0: $AttachmentType$$Type<(any)>): boolean
 "removeData"<T>(arg0: $AttachmentType$$Type<(T)>): T
 "removeData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): T
 "setData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>, arg1: T): T
 "setData"<T>(arg0: $AttachmentType$$Type<(T)>, arg1: T): T
 "getExistingData"<T>(arg0: $Supplier$$Type<($AttachmentType$$Type<(T)>)>): $Optional<(T)>
 "getExistingData"<T>(arg0: $AttachmentType$$Type<(T)>): $Optional<(T)>
 "hasAttachments"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAttachmentHolder$$Type = ($IAttachmentHolder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAttachmentHolder_ = $IAttachmentHolder$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.item.ItemTossEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ItemEvent, $ItemEvent$$Type} from "net.neoforged.neoforge.event.entity.item.ItemEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"

export class $ItemTossEvent extends $ItemEvent implements $ICancellableEvent {

constructor(arg0: $ItemEntity$$Type, arg1: $Player$$Type)

public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemTossEvent$$Type = ($ItemTossEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemTossEvent_ = $ItemTossEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased$Pre" {
import {$ScreenEvent$MouseButtonReleased, $ScreenEvent$MouseButtonReleased$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $ScreenEvent$MouseButtonReleased$Pre extends $ScreenEvent$MouseButtonReleased implements $ICancellableEvent {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer)

public "getMouseY"(): double
public "getMouseX"(): double
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "mouseY"(): double
get "mouseX"(): double
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonReleased$Pre$$Type = ($ScreenEvent$MouseButtonReleased$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonReleased$Pre_ = $ScreenEvent$MouseButtonReleased$Pre$$Type;
}}
declare module "net.neoforged.neoforge.common.world.AuxiliaryLightManager" {
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export interface $AuxiliaryLightManager {

 "getLightAt"(arg0: $BlockPos$$Type): integer
 "setLightAt"(arg0: $BlockPos$$Type, arg1: integer): void
 "removeLightAt"(arg0: $BlockPos$$Type): void
}

export namespace $AuxiliaryLightManager {
const probejs$$marker: never
}
export class $AuxiliaryLightManager$$Static implements $AuxiliaryLightManager {


 "getLightAt"(arg0: $BlockPos$$Type): integer
 "setLightAt"(arg0: $BlockPos$$Type, arg1: integer): void
 "removeLightAt"(arg0: $BlockPos$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AuxiliaryLightManager$$Type = ($AuxiliaryLightManager);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AuxiliaryLightManager_ = $AuxiliaryLightManager$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AdvancementEvent$AdvancementEarnEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AdvancementEvent, $AdvancementEvent$$Type} from "net.neoforged.neoforge.event.entity.player.AdvancementEvent"
import {$AdvancementHolder, $AdvancementHolder$$Type} from "net.minecraft.advancements.AdvancementHolder"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $AdvancementEvent$AdvancementEarnEvent extends $AdvancementEvent {

constructor(arg0: $Player$$Type, arg1: $AdvancementHolder$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AdvancementEvent$AdvancementEarnEvent$$Type = ($AdvancementEvent$AdvancementEarnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AdvancementEvent$AdvancementEarnEvent_ = $AdvancementEvent$AdvancementEarnEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.IdMappingEvent$ModRemapping" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"

export class $IdMappingEvent$ModRemapping {
readonly "registry": $ResourceLocation
readonly "newId": integer
readonly "oldId": integer
readonly "key": $ResourceLocation


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IdMappingEvent$ModRemapping$$Type = ($IdMappingEvent$ModRemapping);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IdMappingEvent$ModRemapping_ = $IdMappingEvent$ModRemapping$$Type;
}}
declare module "net.neoforged.neoforge.event.PlayLevelSoundEvent" {
import {$SoundSource, $SoundSource$$Type} from "net.minecraft.sounds.SoundSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $PlayLevelSoundEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $Holder$$Type<($SoundEvent)>, arg2: $SoundSource$$Type, arg3: float, arg4: float)

public "getLevel"(): $Level
public "getSource"(): $SoundSource
public "getSound"(): $Holder<($SoundEvent)>
public "setSource"(arg0: $SoundSource$$Type): void
public "getNewVolume"(): float
public "getNewPitch"(): float
public "getOriginalPitch"(): float
public "setNewVolume"(arg0: float): void
public "setNewPitch"(arg0: float): void
public "getOriginalVolume"(): float
public "setSound"(arg0: $Holder$$Type<($SoundEvent)>): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "level"(): $Level
get "source"(): $SoundSource
get "sound"(): $Holder<($SoundEvent)>
set "source"(value: $SoundSource$$Type)
get "newVolume"(): float
get "newPitch"(): float
get "originalPitch"(): float
set "newVolume"(value: float)
set "newPitch"(value: float)
get "originalVolume"(): float
set "sound"(value: $Holder$$Type<($SoundEvent)>)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayLevelSoundEvent$$Type = ($PlayLevelSoundEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayLevelSoundEvent_ = $PlayLevelSoundEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IModelBakerExtension" {
import {$TextureAtlasSprite, $TextureAtlasSprite$$Type} from "net.minecraft.client.renderer.texture.TextureAtlasSprite"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Material, $Material$$Type} from "net.minecraft.client.resources.model.Material"
import {$ModelResourceLocation, $ModelResourceLocation$$Type} from "net.minecraft.client.resources.model.ModelResourceLocation"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$ModelState, $ModelState$$Type} from "net.minecraft.client.resources.model.ModelState"
import {$UnbakedModel, $UnbakedModel$$Type} from "net.minecraft.client.resources.model.UnbakedModel"

export interface $IModelBakerExtension {

 "getModelTextureGetter"(): $Function<($Material), ($TextureAtlasSprite)>
 "bake"(arg0: $ResourceLocation$$Type, arg1: $ModelState$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>): $BakedModel
 "getTopLevelModel"(arg0: $ModelResourceLocation$$Type): $UnbakedModel
 "bakeUncached"(arg0: $UnbakedModel$$Type, arg1: $ModelState$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>): $BakedModel
get "modelTextureGetter"(): $Function<($Material), ($TextureAtlasSprite)>
}

export namespace $IModelBakerExtension {
const probejs$$marker: never
}
export class $IModelBakerExtension$$Static implements $IModelBakerExtension {


 "getModelTextureGetter"(): $Function<($Material), ($TextureAtlasSprite)>
 "bake"(arg0: $ResourceLocation$$Type, arg1: $ModelState$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>): $BakedModel
 "getTopLevelModel"(arg0: $ModelResourceLocation$$Type): $UnbakedModel
 "bakeUncached"(arg0: $UnbakedModel$$Type, arg1: $ModelState$$Type, arg2: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>): $BakedModel
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModelBakerExtension$$Type = ($IModelBakerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModelBakerExtension_ = $IModelBakerExtension$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.nodes.PermissionType" {
import {$Class, $Class$$Type} from "java.lang.Class"

export class $PermissionType<T> {


public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "typeName"(): string
public "typeToken"(): $Class<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionType$$Type<T> = ($PermissionType<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionType_<T> = $PermissionType$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.extensions.IBlockStateExtension" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$ServerPlayer$RespawnPosAngle, $ServerPlayer$RespawnPosAngle$$Type} from "net.minecraft.server.level.ServerPlayer$RespawnPosAngle"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ItemAbility, $ItemAbility$$Type} from "net.neoforged.neoforge.common.ItemAbility"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BubbleColumnDirection, $BubbleColumnDirection$$Type} from "net.neoforged.neoforge.common.enums.BubbleColumnDirection"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"
import {$SoundType, $SoundType$$Type} from "net.minecraft.world.level.block.SoundType"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$TreeConfiguration, $TreeConfiguration$$Type} from "net.minecraft.world.level.levelgen.feature.configurations.TreeConfiguration"
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$SignalGetter, $SignalGetter$$Type} from "net.minecraft.world.level.SignalGetter"
import {$Rotation, $Rotation$$Type} from "net.minecraft.world.level.block.Rotation"
import {$BiConsumer, $BiConsumer$$Type} from "java.util.function.BiConsumer"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export interface $IBlockStateExtension {

 "isPortalFrame"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "isEmpty"(): boolean
 "rotate"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $Rotation$$Type): $BlockState
 "hasDynamicLightEmission"(): boolean
 "getEnchantPowerBonus"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): float
 "getExplosionResistance"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): float
 "onDestroyedByPushReaction"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $FluidState$$Type): void
 "getStateAtViewpoint"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Vec3$$Type): $BlockState
 "collisionExtendsVertically"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "onDestroyedByPlayer"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type, arg3: boolean, arg4: $FluidState$$Type): boolean
 "shouldCheckWeakPower"(arg0: $SignalGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "getBeaconColorMultiplier"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): integer
 "shouldDisplayFluidOverlay"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type): boolean
 "getBubbleColumnDirection"(): $BubbleColumnDirection
 "canDropFromExplosion"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): boolean
 "getToolModifiedState"(arg0: $UseOnContext$$Type, arg1: $ItemAbility$$Type, arg2: boolean): $BlockState
 "getAdjacentBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: $PathType$$Type): $PathType
 "canRedstoneConnectTo"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "isFireSource"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "getFlammability"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): integer
 "isFlammable"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "onCaughtFire"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $LivingEntity$$Type): void
 "getFireSpreadSpeed"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): integer
 "shouldHideAdjacentFluidFace"(arg0: $Direction$$Type, arg1: $FluidState$$Type): boolean
 "getCloneItemStack"(arg0: $HitResult$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): $ItemStack
 "getLightEmission"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): integer
 "getSoundType"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): $SoundType
 "getFriction"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): float
 "isStickyBlock"(): boolean
 "hidesNeighborFace"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $Direction$$Type): boolean
 "isScaffolding"(arg0: $LivingEntity$$Type): boolean
 "canEntityDestroy"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "canSustainPlant"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $BlockState$$Type): $TriState
 "onBlockExploded"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): void
 "getAppearance"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type): $BlockState
 "isConduitFrame"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): boolean
 "addRunningEffects"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "canHarvestBlock"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type): boolean
 "setBedOccupied"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type, arg3: boolean): void
 "onNeighborChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): void
 "canBeHydrated"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type, arg3: $BlockPos$$Type): boolean
 "isSlimeBlock"(): boolean
 "getBedDirection"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): $Direction
 "getBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type): $PathType
 "onBlockStateChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type): void
 "addLandingEffects"(arg0: $ServerLevel$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $LivingEntity$$Type, arg4: integer): boolean
 "getWeakChanges"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): boolean
 "getRespawnPosition"(arg0: $EntityType$$Type<(any)>, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: float): $Optional<($ServerPlayer$RespawnPosAngle)>
 "supportsExternalFaceHiding"(): boolean
 "isFertile"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "onTreeGrow"(arg0: $LevelReader$$Type, arg1: $BiConsumer$$Type<($BlockPos), ($BlockState)>, arg2: $RandomSource$$Type, arg3: $BlockPos$$Type, arg4: $TreeConfiguration$$Type): boolean
 "isBurning"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "getExpDrop"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $BlockEntity$$Type, arg3: $Entity$$Type, arg4: $ItemStack$$Type): integer
 "isLadder"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type): boolean
 "isBed"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type): boolean
 "canStickTo"(arg0: $BlockState$$Type): boolean
get "empty"(): boolean
get "bubbleColumnDirection"(): $BubbleColumnDirection
get "stickyBlock"(): boolean
get "slimeBlock"(): boolean
}

export namespace $IBlockStateExtension {
const probejs$$marker: never
}
export class $IBlockStateExtension$$Static implements $IBlockStateExtension {


 "isPortalFrame"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "isEmpty"(): boolean
 "rotate"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $Rotation$$Type): $BlockState
 "hasDynamicLightEmission"(): boolean
 "getEnchantPowerBonus"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): float
 "getExplosionResistance"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): float
 "onDestroyedByPushReaction"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $FluidState$$Type): void
 "getStateAtViewpoint"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Vec3$$Type): $BlockState
 "collisionExtendsVertically"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "onDestroyedByPlayer"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type, arg3: boolean, arg4: $FluidState$$Type): boolean
 "shouldCheckWeakPower"(arg0: $SignalGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "getBeaconColorMultiplier"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): integer
 "shouldDisplayFluidOverlay"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type): boolean
 "getBubbleColumnDirection"(): $BubbleColumnDirection
 "canDropFromExplosion"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): boolean
 "getToolModifiedState"(arg0: $UseOnContext$$Type, arg1: $ItemAbility$$Type, arg2: boolean): $BlockState
 "getAdjacentBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type, arg3: $PathType$$Type): $PathType
 "canRedstoneConnectTo"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "isFireSource"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "getFlammability"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): integer
 "isFlammable"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): boolean
 "onCaughtFire"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $LivingEntity$$Type): void
 "getFireSpreadSpeed"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type): integer
 "shouldHideAdjacentFluidFace"(arg0: $Direction$$Type, arg1: $FluidState$$Type): boolean
 "getCloneItemStack"(arg0: $HitResult$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): $ItemStack
 "getLightEmission"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): integer
 "getSoundType"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): $SoundType
 "getFriction"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): float
 "isStickyBlock"(): boolean
 "hidesNeighborFace"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $Direction$$Type): boolean
 "isScaffolding"(arg0: $LivingEntity$$Type): boolean
 "canEntityDestroy"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "canSustainPlant"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $BlockState$$Type): $TriState
 "onBlockExploded"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Explosion$$Type): void
 "getAppearance"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type): $BlockState
 "isConduitFrame"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): boolean
 "addRunningEffects"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $Entity$$Type): boolean
 "canHarvestBlock"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Player$$Type): boolean
 "setBedOccupied"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type, arg3: boolean): void
 "onNeighborChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockPos$$Type): void
 "canBeHydrated"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $FluidState$$Type, arg3: $BlockPos$$Type): boolean
 "isSlimeBlock"(): boolean
 "getBedDirection"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): $Direction
 "getBlockPathType"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $Mob$$Type): $PathType
 "onBlockStateChange"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type): void
 "addLandingEffects"(arg0: $ServerLevel$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $LivingEntity$$Type, arg4: integer): boolean
 "getWeakChanges"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type): boolean
 "getRespawnPosition"(arg0: $EntityType$$Type<(any)>, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: float): $Optional<($ServerPlayer$RespawnPosAngle)>
 "supportsExternalFaceHiding"(): boolean
 "isFertile"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "onTreeGrow"(arg0: $LevelReader$$Type, arg1: $BiConsumer$$Type<($BlockPos), ($BlockState)>, arg2: $RandomSource$$Type, arg3: $BlockPos$$Type, arg4: $TreeConfiguration$$Type): boolean
 "isBurning"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type): boolean
 "getExpDrop"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $BlockEntity$$Type, arg3: $Entity$$Type, arg4: $ItemStack$$Type): integer
 "isLadder"(arg0: $LevelReader$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type): boolean
 "isBed"(arg0: $BlockGetter$$Type, arg1: $BlockPos$$Type, arg2: $LivingEntity$$Type): boolean
 "canStickTo"(arg0: $BlockState$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockStateExtension$$Type = ($IBlockStateExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockStateExtension_ = $IBlockStateExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$PositionCheck" {
import {$MobSpawnType, $MobSpawnType$$Type} from "net.minecraft.world.entity.MobSpawnType"
import {$ServerLevelAccessor, $ServerLevelAccessor$$Type} from "net.minecraft.world.level.ServerLevelAccessor"
import {$MobSpawnEvent$PositionCheck$Result, $MobSpawnEvent$PositionCheck$Result$$Type} from "net.neoforged.neoforge.event.entity.living.MobSpawnEvent$PositionCheck$Result"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$MobSpawnEvent, $MobSpawnEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobSpawnEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$BaseSpawner, $BaseSpawner$$Type} from "net.minecraft.world.level.BaseSpawner"

export class $MobSpawnEvent$PositionCheck extends $MobSpawnEvent {

constructor(arg0: $Mob$$Type, arg1: $ServerLevelAccessor$$Type, arg2: $MobSpawnType$$Type, arg3: $BaseSpawner$$Type)

public "setResult"(arg0: $MobSpawnEvent$PositionCheck$Result$$Type): void
public "getResult"(): $MobSpawnEvent$PositionCheck$Result
public "getSpawnType"(): $MobSpawnType
public "getSpawner"(): $BaseSpawner
public "getEntity"(): $Entity
set "result"(value: $MobSpawnEvent$PositionCheck$Result$$Type)
get "result"(): $MobSpawnEvent$PositionCheck$Result
get "spawnType"(): $MobSpawnType
get "spawner"(): $BaseSpawner
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnEvent$PositionCheck$$Type = ($MobSpawnEvent$PositionCheck);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnEvent$PositionCheck_ = $MobSpawnEvent$PositionCheck$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderTooltipEvent$GatherComponents" {
import {$TooltipComponent, $TooltipComponent$$Type} from "net.minecraft.world.inventory.tooltip.TooltipComponent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$FormattedText, $FormattedText$$Type} from "net.minecraft.network.chat.FormattedText"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$Either, $Either$$Type} from "com.mojang.datafixers.util.Either"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $RenderTooltipEvent$GatherComponents extends $Event implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: integer, arg2: integer, arg3: $List$$Type<($Either$$Type<($FormattedText$$Type), ($TooltipComponent$$Type)>)>, arg4: integer)

public "setMaxWidth"(arg0: integer): void
public "getMaxWidth"(): integer
public "getItemStack"(): $ItemStack
public "getScreenHeight"(): integer
public "getScreenWidth"(): integer
public "getTooltipElements"(): $List<($Either<($FormattedText), ($TooltipComponent)>)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "maxWidth"(value: integer)
get "maxWidth"(): integer
get "itemStack"(): $ItemStack
get "screenHeight"(): integer
get "screenWidth"(): integer
get "tooltipElements"(): $List<($Either<($FormattedText), ($TooltipComponent)>)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderTooltipEvent$GatherComponents$$Type = ($RenderTooltipEvent$GatherComponents);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderTooltipEvent$GatherComponents_ = $RenderTooltipEvent$GatherComponents$$Type;
}}
declare module "net.neoforged.neoforge.event.ItemStackedOnOtherEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Slot, $Slot$$Type} from "net.minecraft.world.inventory.Slot"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ClickAction, $ClickAction$$Type} from "net.minecraft.world.inventory.ClickAction"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$SlotAccess, $SlotAccess$$Type} from "net.minecraft.world.entity.SlotAccess"

export class $ItemStackedOnOtherEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: $Slot$$Type, arg3: $ClickAction$$Type, arg4: $Player$$Type, arg5: $SlotAccess$$Type)

public "getSlot"(): $Slot
public "getCarriedSlotAccess"(): $SlotAccess
public "getStackedOnItem"(): $ItemStack
public "getClickAction"(): $ClickAction
public "getCarriedItem"(): $ItemStack
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "slot"(): $Slot
get "carriedSlotAccess"(): $SlotAccess
get "stackedOnItem"(): $ItemStack
get "clickAction"(): $ClickAction
get "carriedItem"(): $ItemStack
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemStackedOnOtherEvent$$Type = ($ItemStackedOnOtherEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemStackedOnOtherEvent_ = $ItemStackedOnOtherEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPauseChangeEvent$Pre" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ClientPauseChangeEvent, $ClientPauseChangeEvent$$Type} from "net.neoforged.neoforge.client.event.ClientPauseChangeEvent"

export class $ClientPauseChangeEvent$Pre extends $ClientPauseChangeEvent implements $ICancellableEvent {

constructor(arg0: boolean)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPauseChangeEvent$Pre$$Type = ($ClientPauseChangeEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPauseChangeEvent$Pre_ = $ClientPauseChangeEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.fluids.BaseFlowingFluid$Source" {
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$IdMapper, $IdMapper$$Type} from "net.minecraft.core.IdMapper"
import {$IntegerProperty, $IntegerProperty$$Type} from "net.minecraft.world.level.block.state.properties.IntegerProperty"
import {$BooleanProperty, $BooleanProperty$$Type} from "net.minecraft.world.level.block.state.properties.BooleanProperty"
import {$BaseFlowingFluid$Properties, $BaseFlowingFluid$Properties$$Type} from "net.neoforged.neoforge.fluids.BaseFlowingFluid$Properties"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$BaseFlowingFluid, $BaseFlowingFluid$$Type} from "net.neoforged.neoforge.fluids.BaseFlowingFluid"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $BaseFlowingFluid$Source extends $BaseFlowingFluid {
static readonly "FLUID_STATE_REGISTRY": $IdMapper<($FluidState)>
static readonly "FALLING": $BooleanProperty
static readonly "LEVEL": $IntegerProperty

constructor(arg0: $BaseFlowingFluid$Properties$$Type)

public "getAmount"(arg0: $FluidState$$Type): integer
public "isSource"(arg0: $FluidState$$Type): boolean
public "asHolder"(): $Holder<(any)>
public static "wrap"(arg1: any): $ReplacementMatch
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BaseFlowingFluid$Source$$Type = ($BaseFlowingFluid$Source);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BaseFlowingFluid$Source_ = $BaseFlowingFluid$Source$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.events.PermissionGatherEvent$Handler" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$IPermissionHandlerFactory, $IPermissionHandlerFactory$$Type} from "net.neoforged.neoforge.server.permission.handler.IPermissionHandlerFactory"
import {$PermissionGatherEvent, $PermissionGatherEvent$$Type} from "net.neoforged.neoforge.server.permission.events.PermissionGatherEvent"

export class $PermissionGatherEvent$Handler extends $PermissionGatherEvent {

constructor()

public "getAvailablePermissionHandlerFactories"(): $Map<($ResourceLocation), ($IPermissionHandlerFactory)>
public "addPermissionHandler"(arg0: $ResourceLocation$$Type, arg1: $IPermissionHandlerFactory$$Type): void
get "availablePermissionHandlerFactories"(): $Map<($ResourceLocation), ($IPermissionHandlerFactory)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionGatherEvent$Handler$$Type = ($PermissionGatherEvent$Handler);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionGatherEvent$Handler_ = $PermissionGatherEvent$Handler$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ComputeFovModifierEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ComputeFovModifierEvent extends $Event {

constructor(arg0: $Player$$Type, arg1: float)

public "getFovModifier"(): float
public "setNewFovModifier"(arg0: float): void
public "getPlayer"(): $Player
public "getNewFovModifier"(): float
get "fovModifier"(): float
set "newFovModifier"(value: float)
get "player"(): $Player
get "newFovModifier"(): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ComputeFovModifierEvent$$Type = ($ComputeFovModifierEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ComputeFovModifierEvent_ = $ComputeFovModifierEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.RegistryBuilder" {
import {$RegistryCallback, $RegistryCallback$$Type} from "net.neoforged.neoforge.registries.callback.RegistryCallback"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$BakeCallback, $BakeCallback$$Type} from "net.neoforged.neoforge.registries.callback.BakeCallback"
import {$ClearCallback, $ClearCallback$$Type} from "net.neoforged.neoforge.registries.callback.ClearCallback"
import {$AddCallback, $AddCallback$$Type} from "net.neoforged.neoforge.registries.callback.AddCallback"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export class $RegistryBuilder<T> {

constructor(arg0: $ResourceKey$$Type<($Registry<(T)>)>)

public "callback"(arg0: $RegistryCallback$$Type<(T)>): $RegistryBuilder<(T)>
public "create"(): $Registry<(T)>
public "sync"(arg0: boolean): $RegistryBuilder<(T)>
public "defaultKey"(arg0: $ResourceLocation$$Type): $RegistryBuilder<(T)>
public "defaultKey"(arg0: $ResourceKey$$Type<(T)>): $RegistryBuilder<(T)>
public "maxId"(arg0: integer): $RegistryBuilder<(T)>
public "onAdd"(arg0: $AddCallback$$Type<(T)>): $RegistryBuilder<(T)>
public "onClear"(arg0: $ClearCallback$$Type<(T)>): $RegistryBuilder<(T)>
public "onBake"(arg0: $BakeCallback$$Type<(T)>): $RegistryBuilder<(T)>
/**
 * 
 * @deprecated
 */
public "withIntrusiveHolders"(): $RegistryBuilder<(T)>
public "disableRegistrationCheck"(): $RegistryBuilder<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegistryBuilder$$Type<T> = ($RegistryBuilder<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegistryBuilder_<T> = $RegistryBuilder$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.OnDatapackSyncEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$PlayerList, $PlayerList$$Type} from "net.minecraft.server.players.PlayerList"

export class $OnDatapackSyncEvent extends $Event {

constructor(arg0: $PlayerList$$Type, arg1: $ServerPlayer$$Type)

public "getPlayerList"(): $PlayerList
public "getRelevantPlayers"(): $Stream<($ServerPlayer)>
public "getPlayer"(): $ServerPlayer
get "playerList"(): $PlayerList
get "relevantPlayers"(): $Stream<($ServerPlayer)>
get "player"(): $ServerPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $OnDatapackSyncEvent$$Type = ($OnDatapackSyncEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $OnDatapackSyncEvent_ = $OnDatapackSyncEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$EntityInteract" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerInteractEvent$EntityInteract extends $PlayerInteractEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $InteractionHand$$Type, arg2: $Entity$$Type)

public "getTarget"(): $Entity
public "getCancellationResult"(): $InteractionResult
public "setCancellationResult"(arg0: $InteractionResult$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "target"(): $Entity
get "cancellationResult"(): $InteractionResult
set "cancellationResult"(value: $InteractionResult$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$EntityInteract$$Type = ($PlayerInteractEvent$EntityInteract);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$EntityInteract_ = $PlayerInteractEvent$EntityInteract$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingSwapItemsEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingSwapItemsEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingSwapItemsEvent$$Type = ($LivingSwapItemsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingSwapItemsEvent_ = $LivingSwapItemsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterDimensionSpecialEffectsEvent" {
import {$DimensionSpecialEffects, $DimensionSpecialEffects$$Type} from "net.minecraft.client.renderer.DimensionSpecialEffects"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterDimensionSpecialEffectsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceLocation$$Type), ($DimensionSpecialEffects$$Type)>)

public "register"(arg0: $ResourceLocation$$Type, arg1: $DimensionSpecialEffects$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterDimensionSpecialEffectsEvent$$Type = ($RegisterDimensionSpecialEffectsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterDimensionSpecialEffectsEvent_ = $RegisterDimensionSpecialEffectsEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.damagesource.IDeathMessageProvider" {
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$CombatEntry, $CombatEntry$$Type} from "net.minecraft.world.damagesource.CombatEntry"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export interface $IDeathMessageProvider {

 "getDeathMessage"(arg0: $LivingEntity$$Type, arg1: $CombatEntry$$Type, arg2: $CombatEntry$$Type): $Component

(arg0: $LivingEntity, arg1: $CombatEntry, arg2: $CombatEntry): $Component$$Type
}

export namespace $IDeathMessageProvider {
const DEFAULT: $IDeathMessageProvider
const probejs$$marker: never
}
export class $IDeathMessageProvider$$Static implements $IDeathMessageProvider {
static readonly "DEFAULT": $IDeathMessageProvider


 "getDeathMessage"(arg0: $LivingEntity$$Type, arg1: $CombatEntry$$Type, arg2: $CombatEntry$$Type): $Component
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IDeathMessageProvider$$Type = ((arg0: $LivingEntity, arg1: $CombatEntry, arg2: $CombatEntry) => $Component$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IDeathMessageProvider_ = $IDeathMessageProvider$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$BlockToolModificationEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$ItemAbility, $ItemAbility$$Type} from "net.neoforged.neoforge.common.ItemAbility"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$BlockToolModificationEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $BlockState$$Type, arg1: $UseOnContext$$Type, arg2: $ItemAbility$$Type, arg3: boolean)

public "getContext"(): $UseOnContext
public "isSimulated"(): boolean
public "getFinalState"(): $BlockState
public "setFinalState"(arg0: $BlockState$$Type): void
public "getHeldItemStack"(): $ItemStack
public "getItemAbility"(): $ItemAbility
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "context"(): $UseOnContext
get "simulated"(): boolean
get "finalState"(): $BlockState
set "finalState"(value: $BlockState$$Type)
get "heldItemStack"(): $ItemStack
get "itemAbility"(): $ItemAbility
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$BlockToolModificationEvent$$Type = ($BlockEvent$BlockToolModificationEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$BlockToolModificationEvent_ = $BlockEvent$BlockToolModificationEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent extends $Event {

constructor(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type)

public "getState"(): $BlockState
public "getLevel"(): $LevelAccessor
public "getPos"(): $BlockPos
get "state"(): $BlockState
get "level"(): $LevelAccessor
get "pos"(): $BlockPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$$Type = ($BlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent_ = $BlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.RegisterGameTestsEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Set, $Set$$Type} from "java.util.Set"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Method, $Method$$Type} from "java.lang.reflect.Method"

export class $RegisterGameTestsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Set$$Type<($Method$$Type)>)

public "register"(arg0: $Class$$Type<(any)>): void
public "register"(arg0: $Method$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterGameTestsEvent$$Type = ($RegisterGameTestsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterGameTestsEvent_ = $RegisterGameTestsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent$EnderPearl" {
import {$ThrownEnderpearl, $ThrownEnderpearl$$Type} from "net.minecraft.world.entity.projectile.ThrownEnderpearl"
import {$EntityTeleportEvent, $EntityTeleportEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityTeleportEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"

export class $EntityTeleportEvent$EnderPearl extends $EntityTeleportEvent implements $ICancellableEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: double, arg2: double, arg3: double, arg4: $ThrownEnderpearl$$Type, arg5: float, arg6: $HitResult$$Type)

public "getAttackDamage"(): float
public "getPearlEntity"(): $ThrownEnderpearl
public "setAttackDamage"(arg0: float): void
public "getHitResult"(): $HitResult
public "getPlayer"(): $ServerPlayer
get "attackDamage"(): float
get "pearlEntity"(): $ThrownEnderpearl
set "attackDamage"(value: float)
get "hitResult"(): $HitResult
get "player"(): $ServerPlayer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$EnderPearl$$Type = ($EntityTeleportEvent$EnderPearl);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent$EnderPearl_ = $EntityTeleportEvent$EnderPearl$$Type;
}}
declare module "net.neoforged.neoforge.client.event.CalculateDetachedCameraDistanceEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"

export class $CalculateDetachedCameraDistanceEvent extends $Event {

constructor(arg0: $Camera$$Type, arg1: boolean, arg2: float, arg3: float)

public "getCamera"(): $Camera
public "isCameraFlipped"(): boolean
public "setDistance"(arg0: float): void
public "getDistance"(): float
public "getEntityScalingFactor"(): float
get "camera"(): $Camera
get "cameraFlipped"(): boolean
set "distance"(value: float)
get "distance"(): float
get "entityScalingFactor"(): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CalculateDetachedCameraDistanceEvent$$Type = ($CalculateDetachedCameraDistanceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CalculateDetachedCameraDistanceEvent_ = $CalculateDetachedCameraDistanceEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.LevelTickEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"

export class $LevelTickEvent extends $Event {


public "getLevel"(): $Level
public "hasTime"(): boolean
get "level"(): $Level
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelTickEvent$$Type = ($LevelTickEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelTickEvent_ = $LevelTickEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.server.ServerStoppedEvent" {
import {$ServerLifecycleEvent, $ServerLifecycleEvent$$Type} from "net.neoforged.neoforge.event.server.ServerLifecycleEvent"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerStoppedEvent extends $ServerLifecycleEvent {

constructor(arg0: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerStoppedEvent$$Type = ($ServerStoppedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerStoppedEvent_ = $ServerStoppedEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityAttributeCreationEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$AttributeSupplier, $AttributeSupplier$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeSupplier"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $EntityAttributeCreationEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($EntityType$$Type<($LivingEntity$$Type)>), ($AttributeSupplier$$Type)>)

public "put"(arg0: $EntityType$$Type<($LivingEntity$$Type)>, arg1: $AttributeSupplier$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityAttributeCreationEvent$$Type = ($EntityAttributeCreationEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityAttributeCreationEvent_ = $EntityAttributeCreationEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.enchanting.GetEnchantmentLevelEvent" {
import {$ItemEnchantments$Mutable, $ItemEnchantments$Mutable$$Type} from "net.minecraft.world.item.enchantment.ItemEnchantments$Mutable"
import {$Enchantment, $Enchantment$$Type} from "net.minecraft.world.item.enchantment.Enchantment"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$HolderLookup$RegistryLookup, $HolderLookup$RegistryLookup$$Type} from "net.minecraft.core.HolderLookup$RegistryLookup"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Holder$Reference, $Holder$Reference$$Type} from "net.minecraft.core.Holder$Reference"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $GetEnchantmentLevelEvent extends $Event {

constructor(arg0: $ItemStack$$Type, arg1: $ItemEnchantments$Mutable$$Type, arg2: $Holder$$Type<($Enchantment)>, arg3: $HolderLookup$RegistryLookup$$Type<($Enchantment$$Type)>)

public "getStack"(): $ItemStack
public "getLookup"(): $HolderLookup$RegistryLookup<($Enchantment)>
public "getHolder"(arg0: $ResourceKey$$Type<($Enchantment)>): $Optional<($Holder$Reference<($Enchantment)>)>
public "getEnchantments"(): $ItemEnchantments$Mutable
public "getTargetEnchant"(): $Holder<($Enchantment)>
public "isTargetting"(arg0: $Holder$$Type<($Enchantment)>): boolean
public "isTargetting"(arg0: $ResourceKey$$Type<($Enchantment)>): boolean
get "stack"(): $ItemStack
get "lookup"(): $HolderLookup$RegistryLookup<($Enchantment)>
get "enchantments"(): $ItemEnchantments$Mutable
get "targetEnchant"(): $Holder<($Enchantment)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GetEnchantmentLevelEvent$$Type = ($GetEnchantmentLevelEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GetEnchantmentLevelEvent_ = $GetEnchantmentLevelEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ModelEvent$ModifyBakingResult" {
import {$TextureAtlasSprite, $TextureAtlasSprite$$Type} from "net.minecraft.client.renderer.texture.TextureAtlasSprite"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ModelEvent, $ModelEvent$$Type} from "net.neoforged.neoforge.client.event.ModelEvent"
import {$Material, $Material$$Type} from "net.minecraft.client.resources.model.Material"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$ModelResourceLocation, $ModelResourceLocation$$Type} from "net.minecraft.client.resources.model.ModelResourceLocation"
import {$ModelBakery, $ModelBakery$$Type} from "net.minecraft.client.resources.model.ModelBakery"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $ModelEvent$ModifyBakingResult extends $ModelEvent implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ModelResourceLocation$$Type), ($BakedModel$$Type)>, arg1: $Function$$Type<($Material), ($TextureAtlasSprite$$Type)>, arg2: $ModelBakery$$Type)

public "getTextureGetter"(): $Function<($Material), ($TextureAtlasSprite)>
public "getModels"(): $Map<($ModelResourceLocation), ($BakedModel)>
public "getModelBakery"(): $ModelBakery
get "textureGetter"(): $Function<($Material), ($TextureAtlasSprite)>
get "models"(): $Map<($ModelResourceLocation), ($BakedModel)>
get "modelBakery"(): $ModelBakery
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelEvent$ModifyBakingResult$$Type = ($ModelEvent$ModifyBakingResult);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelEvent$ModifyBakingResult_ = $ModelEvent$ModifyBakingResult$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterClientReloadListenersEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PreparableReloadListener, $PreparableReloadListener$$Type} from "net.minecraft.server.packs.resources.PreparableReloadListener"
import {$ReloadableResourceManager, $ReloadableResourceManager$$Type} from "net.minecraft.server.packs.resources.ReloadableResourceManager"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterClientReloadListenersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ReloadableResourceManager$$Type)

public "registerReloadListener"(arg0: $PreparableReloadListener$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterClientReloadListenersEvent$$Type = ($RegisterClientReloadListenersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterClientReloadListenersEvent_ = $RegisterClientReloadListenersEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.RegisterEvent" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$RegisterEvent$RegisterHelper, $RegisterEvent$RegisterHelper$$Type} from "net.neoforged.neoforge.registries.RegisterEvent$RegisterHelper"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $RegisterEvent extends $Event implements $IModBusEvent {


public "register"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Consumer$$Type<($RegisterEvent$RegisterHelper<(T)>)>): void
public "register"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $ResourceLocation$$Type, arg2: $Supplier$$Type<(T)>): void
public "getRegistryKey"(): $ResourceKey<($Registry<(any)>)>
public "getRegistry"(): $Registry<(any)>
public "getRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $Registry<(T)>
get "registryKey"(): $ResourceKey<($Registry<(any)>)>
get "registry"(): $Registry<(any)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterEvent$$Type = ($RegisterEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterEvent_ = $RegisterEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.conditions.WithConditions$Builder" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$WithConditions, $WithConditions$$Type} from "net.neoforged.neoforge.common.conditions.WithConditions"
import {$ICondition, $ICondition$$Type} from "net.neoforged.neoforge.common.conditions.ICondition"

export class $WithConditions$Builder<T> {

constructor()

public "build"(): $WithConditions<(T)>
public "withCarrier"(arg0: T): $WithConditions$Builder<(T)>
public "addCondition"(...arg0: ($ICondition$$Type)[]): $WithConditions$Builder<(T)>
public "addCondition"(arg0: $Collection$$Type<($ICondition$$Type)>): $WithConditions$Builder<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $WithConditions$Builder$$Type<T> = ($WithConditions$Builder<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $WithConditions$Builder_<T> = $WithConditions$Builder$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.extensions.IBlockEntityExtension" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$ClientboundBlockEntityDataPacket, $ClientboundBlockEntityDataPacket$$Type} from "net.minecraft.network.protocol.game.ClientboundBlockEntityDataPacket"
import {$ModelData, $ModelData$$Type} from "net.neoforged.neoforge.client.model.data.ModelData"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $IBlockEntityExtension {

 "handleUpdateTag"(arg0: $CompoundTag$$Type, arg1: $HolderLookup$Provider$$Type): void
 "onDataPacket"(arg0: $Connection$$Type, arg1: $ClientboundBlockEntityDataPacket$$Type, arg2: $HolderLookup$Provider$$Type): void
 "onChunkUnloaded"(): void
 "invalidateCapabilities"(): void
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
 "onLoad"(): void
 "getPersistentData"(): $CompoundTag
 "requestModelDataUpdate"(): void
 "getModelData"(): $ModelData

(): $CompoundTag$$Type
get "persistentData"(): $CompoundTag
get "modelData"(): $ModelData
}

export namespace $IBlockEntityExtension {
const probejs$$marker: never
}
export class $IBlockEntityExtension$$Static implements $IBlockEntityExtension {


 "handleUpdateTag"(arg0: $CompoundTag$$Type, arg1: $HolderLookup$Provider$$Type): void
 "onDataPacket"(arg0: $Connection$$Type, arg1: $ClientboundBlockEntityDataPacket$$Type, arg2: $HolderLookup$Provider$$Type): void
 "onChunkUnloaded"(): void
 "invalidateCapabilities"(): void
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
 "onLoad"(): void
 "getPersistentData"(): $CompoundTag
 "requestModelDataUpdate"(): void
 "getModelData"(): $ModelData
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockEntityExtension$$Type = (() => $CompoundTag$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockEntityExtension_ = $IBlockEntityExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$SaveToFile" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$File, $File$$Type} from "java.io.File"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$SaveToFile extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $File$$Type, arg2: string)

public "getEntity"(): $LivingEntity
public "getPlayerUUID"(): string
public "getPlayerDirectory"(): $File
public "getPlayerFile"(arg0: string): $File
get "entity"(): $LivingEntity
get "playerUUID"(): string
get "playerDirectory"(): $File
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$SaveToFile$$Type = ($PlayerEvent$SaveToFile);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$SaveToFile_ = $PlayerEvent$SaveToFile$$Type;
}}
declare module "net.neoforged.neoforge.client.event.InputEvent$Key" {
import {$InputEvent, $InputEvent$$Type} from "net.neoforged.neoforge.client.event.InputEvent"

export class $InputEvent$Key extends $InputEvent {

constructor(arg0: integer, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getKey"(): integer
public "getScanCode"(): integer
public "getAction"(): integer
get "modifiers"(): integer
get "key"(): integer
get "scanCode"(): integer
get "action"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputEvent$Key$$Type = ($InputEvent$Key);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputEvent$Key_ = $InputEvent$Key$$Type;
}}
declare module "net.neoforged.neoforge.network.event.RegisterPayloadHandlersEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$PayloadRegistrar, $PayloadRegistrar$$Type} from "net.neoforged.neoforge.network.registration.PayloadRegistrar"

export class $RegisterPayloadHandlersEvent extends $Event implements $IModBusEvent {

constructor()

public "registrar"(arg0: string): $PayloadRegistrar
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterPayloadHandlersEvent$$Type = ($RegisterPayloadHandlersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterPayloadHandlersEvent_ = $RegisterPayloadHandlersEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.VanillaGameEvent" {
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$GameEvent$Context, $GameEvent$Context$$Type} from "net.minecraft.world.level.gameevent.GameEvent$Context"
import {$GameEvent, $GameEvent$$Type} from "net.minecraft.world.level.gameevent.GameEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $VanillaGameEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $Holder$$Type<($GameEvent)>, arg2: $Vec3$$Type, arg3: $GameEvent$Context$$Type)

public "getCause"(): $Entity
public "getContext"(): $GameEvent$Context
public "getLevel"(): $Level
public "getEventPosition"(): $Vec3
public "getVanillaEvent"(): $Holder<($GameEvent)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "cause"(): $Entity
get "context"(): $GameEvent$Context
get "level"(): $Level
get "eventPosition"(): $Vec3
get "vanillaEvent"(): $Holder<($GameEvent)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VanillaGameEvent$$Type = ($VanillaGameEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VanillaGameEvent_ = $VanillaGameEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IServerGamePacketListenerExtension" {
import {$Iterable, $Iterable$$Type} from "java.lang.Iterable"
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$CrashReport, $CrashReport$$Type} from "net.minecraft.CrashReport"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$PacketSendListener, $PacketSendListener$$Type} from "net.minecraft.network.PacketSendListener"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$DisconnectionDetails, $DisconnectionDetails$$Type} from "net.minecraft.network.DisconnectionDetails"
import {$ConnectionType, $ConnectionType$$Type} from "net.neoforged.neoforge.network.connection.ConnectionType"
import {$IServerCommonPacketListenerExtension, $IServerCommonPacketListenerExtension$$Type} from "net.neoforged.neoforge.common.extensions.IServerCommonPacketListenerExtension"
import {$Exception, $Exception$$Type} from "java.lang.Exception"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$ReentrantBlockableEventLoop, $ReentrantBlockableEventLoop$$Type} from "net.minecraft.util.thread.ReentrantBlockableEventLoop"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$CrashReportCategory, $CrashReportCategory$$Type} from "net.minecraft.CrashReportCategory"

export interface $IServerGamePacketListenerExtension extends $IServerCommonPacketListenerExtension {

 "sendBundled"(...arg0: ($CustomPacketPayload$$Type)[]): void
 "sendBundled"(arg0: $Iterable$$Type<($CustomPacketPayload$$Type)>): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
get "connection"(): $Connection
get "connectionType"(): $ConnectionType
get "mainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
get "acceptingMessages"(): boolean
}

export namespace $IServerGamePacketListenerExtension {
const probejs$$marker: never
}
export class $IServerGamePacketListenerExtension$$Static implements $IServerGamePacketListenerExtension {


 "sendBundled"(...arg0: ($CustomPacketPayload$$Type)[]): void
 "sendBundled"(arg0: $Iterable$$Type<($CustomPacketPayload$$Type)>): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "send"(arg0: $Packet$$Type<(any)>, arg1: $PacketSendListener$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type, arg1: $PacketSendListener$$Type): void
 "getConnection"(): $Connection
 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IServerGamePacketListenerExtension$$Type = ($IServerGamePacketListenerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IServerGamePacketListenerExtension_ = $IServerGamePacketListenerExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.level.ExplosionEvent$Detonate" {
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$List, $List$$Type} from "java.util.List"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ExplosionEvent, $ExplosionEvent$$Type} from "net.neoforged.neoforge.event.level.ExplosionEvent"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $ExplosionEvent$Detonate extends $ExplosionEvent {

constructor(arg0: $Level$$Type, arg1: $Explosion$$Type, arg2: $List$$Type<($Entity$$Type)>)

public "getAffectedBlocks"(): $List<($BlockPos)>
public "getAffectedEntities"(): $List<($Entity)>
get "affectedBlocks"(): $List<($BlockPos)>
get "affectedEntities"(): $List<($Entity)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExplosionEvent$Detonate$$Type = ($ExplosionEvent$Detonate);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExplosionEvent$Detonate_ = $ExplosionEvent$Detonate$$Type;
}}
declare module "net.neoforged.neoforge.event.level.NoteBlockEvent$Octave" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $NoteBlockEvent$Octave extends $Enum<($NoteBlockEvent$Octave)> {
static readonly "HIGH": $NoteBlockEvent$Octave
static readonly "LOW": $NoteBlockEvent$Octave
static readonly "MID": $NoteBlockEvent$Octave


public static "values"(): ($NoteBlockEvent$Octave)[]
public static "valueOf"(arg0: string): $NoteBlockEvent$Octave
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NoteBlockEvent$Octave$$Type = (("low") | ("mid") | ("high"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NoteBlockEvent$Octave_ = $NoteBlockEvent$Octave$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.ICapabilityProvider" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ICapabilityProvider<O, C, T> {

 "getCapability"(arg0: O, arg1: C): T

(arg0: O, arg1: C): T
}

export namespace $ICapabilityProvider {
const probejs$$marker: never
}
export class $ICapabilityProvider$$Static<O, C, T> implements $ICapabilityProvider {


 "getCapability"(arg0: O, arg1: C): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICapabilityProvider$$Type<O, C, T> = ((arg0: O, arg1: C) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICapabilityProvider_<O, C, T> = $ICapabilityProvider$$Type<(O), (C), (T)>;
}}
declare module "net.neoforged.neoforge.client.model.ExtraFaceData" {
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$JsonElement, $JsonElement$$Type} from "com.google.gson.JsonElement"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ExtraFaceData extends $Record {
static readonly "CODEC": $Codec<($ExtraFaceData)>
static readonly "COLOR": $Codec<(integer)>
static readonly "DEFAULT": $ExtraFaceData

constructor(color: integer, blockLight: integer, skyLight: integer, ambientOcclusion: boolean)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public static "read"(arg0: $JsonElement$$Type, arg1: $ExtraFaceData$$Type): $ExtraFaceData
public "color"(): integer
public "ambientOcclusion"(): boolean
public "skyLight"(): integer
public "blockLight"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExtraFaceData$$Type = ({"skyLight"?: integer, "ambientOcclusion"?: boolean, "color"?: integer, "blockLight"?: integer}) | ([skyLight?: integer, ambientOcclusion?: boolean, color?: integer, blockLight?: integer]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExtraFaceData_ = $ExtraFaceData$$Type;
}}
declare module "net.neoforged.neoforge.client.model.lighting.QuadLighter" {
import {$PoseStack$Pose, $PoseStack$Pose$$Type} from "com.mojang.blaze3d.vertex.PoseStack$Pose"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$VertexConsumer, $VertexConsumer$$Type} from "com.mojang.blaze3d.vertex.VertexConsumer"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"
import {$BakedQuad, $BakedQuad$$Type} from "net.minecraft.client.renderer.block.model.BakedQuad"

export class $QuadLighter {


public "reset"(): void
public "setup"(arg0: $BlockAndTintGetter$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type): void
public "process"(arg0: $VertexConsumer$$Type, arg1: $PoseStack$Pose$$Type, arg2: $BakedQuad$$Type, arg3: integer): void
public static "calculateShade"(arg0: float, arg1: float, arg2: float, arg3: boolean): float
public "getComputedBrightness"(): (float)[]
public "computeLightingForQuad"(arg0: (integer)[], arg1: boolean): void
public "computeLightingForQuad"(arg0: $BakedQuad$$Type): void
public "getComputedLightmap"(): (integer)[]
get "computedBrightness"(): (float)[]
get "computedLightmap"(): (integer)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $QuadLighter$$Type = ($QuadLighter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $QuadLighter_ = $QuadLighter$$Type;
}}
declare module "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet" {
import {$Iterator, $Iterator$$Type} from "java.util.Iterator"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$Spliterator, $Spliterator$$Type} from "java.util.Spliterator"
import {$List, $List$$Type} from "java.util.List"
import {$IHolderSetExtension$SerializationType, $IHolderSetExtension$SerializationType$$Type} from "net.neoforged.neoforge.common.extensions.IHolderSetExtension$SerializationType"
import {$Runnable, $Runnable$$Type} from "java.lang.Runnable"
import {$HolderOwner, $HolderOwner$$Type} from "net.minecraft.core.HolderOwner"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$HolderSet$Direct, $HolderSet$Direct$$Type} from "net.minecraft.core.HolderSet$Direct"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$Either, $Either$$Type} from "com.mojang.datafixers.util.Either"
import {$HolderSet, $HolderSet$$Type} from "net.minecraft.core.HolderSet"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$HolderSet$Named, $HolderSet$Named$$Type} from "net.minecraft.core.HolderSet$Named"
import {$HolderSetType, $HolderSetType$$Type} from "net.neoforged.neoforge.registries.holdersets.HolderSetType"

export interface $ICustomHolderSet<T> extends $HolderSet<(T)> {

 "type"(): $HolderSetType
 "serializationType"(): $IHolderSetExtension$SerializationType
 "size"(): integer
 "get"(arg0: integer): $Holder<(T)>
 "stream"(): $Stream<($Holder<(T)>)>
 "contains"(arg0: $Holder$$Type<(T)>): boolean
 "unwrap"(): $Either<($TagKey<(T)>), ($List<($Holder<(T)>)>)>
 "getRandomElement"(arg0: $RandomSource$$Type): $Optional<($Holder<(T)>)>
 "canSerializeIn"(arg0: $HolderOwner$$Type<(T)>): boolean
 "unwrapKey"(): $Optional<($TagKey<(T)>)>
 "iterator"(): $Iterator<($Holder<(T)>)>
 "spliterator"(): $Spliterator<($Holder<(T)>)>
 "forEach"(arg0: $Consumer$$Type<($Holder<(T)>)>): void
 "addInvalidationListener"(arg0: $Runnable$$Type): void
[Symbol.iterator](): IterableIterator<$Holder<(T)>>;
}

export namespace $ICustomHolderSet {
function empty<T>(): $HolderSet<(T)>
function direct<E, T>(arg0: $Function$$Type<(E), ($Holder$$Type<(T)>)>, ...arg1: (E)[]): $HolderSet$Direct<(T)>
function direct<T>(...arg0: ($Holder$$Type<(T)>)[]): $HolderSet$Direct<(T)>
function direct<T>(arg0: $List$$Type<($Holder$$Type<(T)>)>): $HolderSet$Direct<(T)>
function direct<E, T>(arg0: $Function$$Type<(E), ($Holder$$Type<(T)>)>, arg1: $Collection$$Type<(E)>): $HolderSet$Direct<(T)>
function emptyNamed<T>(arg0: $HolderOwner$$Type<(T)>, arg1: $TagKey$$Type<(T)>): $HolderSet$Named<(T)>
const probejs$$marker: never
}
export class $ICustomHolderSet$$Static<T> implements $ICustomHolderSet {


 "type"(): $HolderSetType
 "serializationType"(): $IHolderSetExtension$SerializationType
 "size"(): integer
 "get"(arg0: integer): $Holder<(T)>
 "stream"(): $Stream<($Holder<(T)>)>
 "contains"(arg0: $Holder$$Type<(T)>): boolean
static "empty"<T>(): $HolderSet<(T)>
 "unwrap"(): $Either<($TagKey<(T)>), ($List<($Holder<(T)>)>)>
static "direct"<E, T>(arg0: $Function$$Type<(E), ($Holder$$Type<(T)>)>, ...arg1: (E)[]): $HolderSet$Direct<(T)>
static "direct"<T>(...arg0: ($Holder$$Type<(T)>)[]): $HolderSet$Direct<(T)>
static "direct"<T>(arg0: $List$$Type<($Holder$$Type<(T)>)>): $HolderSet$Direct<(T)>
static "direct"<E, T>(arg0: $Function$$Type<(E), ($Holder$$Type<(T)>)>, arg1: $Collection$$Type<(E)>): $HolderSet$Direct<(T)>
 "getRandomElement"(arg0: $RandomSource$$Type): $Optional<($Holder<(T)>)>
/**
 * 
 * @deprecated
 */
static "emptyNamed"<T>(arg0: $HolderOwner$$Type<(T)>, arg1: $TagKey$$Type<(T)>): $HolderSet$Named<(T)>
 "canSerializeIn"(arg0: $HolderOwner$$Type<(T)>): boolean
 "unwrapKey"(): $Optional<($TagKey<(T)>)>
 "iterator"(): $Iterator<($Holder<(T)>)>
 "spliterator"(): $Spliterator<($Holder<(T)>)>
 "forEach"(arg0: $Consumer$$Type<($Holder<(T)>)>): void
 "addInvalidationListener"(arg0: $Runnable$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICustomHolderSet$$Type<T> = ($ICustomHolderSet<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICustomHolderSet_<T> = $ICustomHolderSet$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.event.ViewportEvent" {
import {$GameRenderer, $GameRenderer$$Type} from "net.minecraft.client.renderer.GameRenderer"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"

export class $ViewportEvent extends $Event {

constructor(arg0: $GameRenderer$$Type, arg1: $Camera$$Type, arg2: double)

public "getCamera"(): $Camera
public "getRenderer"(): $GameRenderer
public "getPartialTick"(): double
get "camera"(): $Camera
get "renderer"(): $GameRenderer
get "partialTick"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ViewportEvent$$Type = ($ViewportEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ViewportEvent_ = $ViewportEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.sound.SoundEvent" {
import {$SoundEngine, $SoundEngine$$Type} from "net.minecraft.client.sounds.SoundEngine"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $SoundEvent extends $Event {


public "getEngine"(): $SoundEngine
get "engine"(): $SoundEngine
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SoundEvent$$Type = ($SoundEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SoundEvent_ = $SoundEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased$Post$Result" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $ScreenEvent$MouseButtonReleased$Post$Result extends $Enum<($ScreenEvent$MouseButtonReleased$Post$Result)> {
static readonly "FORCE_HANDLED": $ScreenEvent$MouseButtonReleased$Post$Result
static readonly "FORCE_UNHANDLED": $ScreenEvent$MouseButtonReleased$Post$Result
static readonly "DEFAULT": $ScreenEvent$MouseButtonReleased$Post$Result


public static "values"(): ($ScreenEvent$MouseButtonReleased$Post$Result)[]
public static "valueOf"(arg0: string): $ScreenEvent$MouseButtonReleased$Post$Result
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonReleased$Post$Result$$Type = (("force_handled") | ("default") | ("force_unhandled"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonReleased$Post$Result_ = $ScreenEvent$MouseButtonReleased$Post$Result$$Type;
}}
declare module "net.neoforged.neoforge.client.entity.animation.AnimationKeyframeTarget" {
import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"

export interface $AnimationKeyframeTarget {

 "apply"(arg0: float, arg1: float, arg2: float): $Vector3f

(arg0: float, arg1: float, arg2: float): $Vector3f$$Type
}

export namespace $AnimationKeyframeTarget {
const probejs$$marker: never
}
export class $AnimationKeyframeTarget$$Static implements $AnimationKeyframeTarget {


 "apply"(arg0: float, arg1: float, arg2: float): $Vector3f
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnimationKeyframeTarget$$Type = ((arg0: float, arg1: float, arg2: float) => $Vector3f$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnimationKeyframeTarget_ = $AnimationKeyframeTarget$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AttackEntityEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $AttackEntityEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $Entity$$Type)

public "getTarget"(): $Entity
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "target"(): $Entity
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttackEntityEvent$$Type = ($AttackEntityEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttackEntityEvent_ = $AttackEntityEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.gui.GuiLayerManager$NamedLayer" {
import {$LayeredDraw$Layer, $LayeredDraw$Layer$$Type} from "net.minecraft.client.gui.LayeredDraw$Layer"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $GuiLayerManager$NamedLayer extends $Record {

constructor(name: $ResourceLocation$$Type, layer: $LayeredDraw$Layer$$Type)

public "name"(): $ResourceLocation
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "layer"(): $LayeredDraw$Layer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiLayerManager$NamedLayer$$Type = ({"name"?: $ResourceLocation$$Type, "layer"?: $LayeredDraw$Layer$$Type}) | ([name?: $ResourceLocation$$Type, layer?: $LayeredDraw$Layer$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiLayerManager$NamedLayer_ = $GuiLayerManager$NamedLayer$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPauseChangeEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ClientPauseChangeEvent extends $Event {

constructor(arg0: boolean)

public "isPaused"(): boolean
get "paused"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPauseChangeEvent$$Type = ($ClientPauseChangeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPauseChangeEvent_ = $ClientPauseChangeEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.NoteBlockEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$NoteBlockEvent$Note, $NoteBlockEvent$Note$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent$Note"
import {$NoteBlockEvent$Octave, $NoteBlockEvent$Octave$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent$Octave"

export class $NoteBlockEvent extends $BlockEvent {


public "getNote"(): $NoteBlockEvent$Note
public "getOctave"(): $NoteBlockEvent$Octave
public "setNote"(arg0: $NoteBlockEvent$Note$$Type, arg1: $NoteBlockEvent$Octave$$Type): void
public "getVanillaNoteId"(): integer
get "note"(): $NoteBlockEvent$Note
get "octave"(): $NoteBlockEvent$Octave
get "vanillaNoteId"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NoteBlockEvent$$Type = ($NoteBlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NoteBlockEvent_ = $NoteBlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseInput" {
import {$ScreenEvent, $ScreenEvent$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent"

export class $ScreenEvent$MouseInput extends $ScreenEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseInput$$Type = ($ScreenEvent$MouseInput);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseInput_ = $ScreenEvent$MouseInput$$Type;
}}
declare module "net.neoforged.neoforge.data.event.GatherDataEvent" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$CompletableFuture, $CompletableFuture$$Type} from "java.util.concurrent.CompletableFuture"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ExistingFileHelper, $ExistingFileHelper$$Type} from "net.neoforged.neoforge.common.data.ExistingFileHelper"
import {$GatherDataEvent$DataGeneratorConfig, $GatherDataEvent$DataGeneratorConfig$$Type} from "net.neoforged.neoforge.data.event.GatherDataEvent$DataGeneratorConfig"
import {$Set, $Set$$Type} from "java.util.Set"
import {$DataGenerator, $DataGenerator$$Type} from "net.minecraft.data.DataGenerator"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$ModContainer, $ModContainer$$Type} from "net.neoforged.fml.ModContainer"

export class $GatherDataEvent extends $Event implements $IModBusEvent {

constructor(arg0: $ModContainer$$Type, arg1: $DataGenerator$$Type, arg2: $GatherDataEvent$DataGeneratorConfig$$Type, arg3: $ExistingFileHelper$$Type)

public "validate"(): boolean
public "getGenerator"(): $DataGenerator
public "getInputs"(): $Collection<($Path)>
public "includeDev"(): boolean
public "getMods"(): $Set<(string)>
public "getLookupProvider"(): $CompletableFuture<($HolderLookup$Provider)>
public "includeServer"(): boolean
public "includeClient"(): boolean
public "getModContainer"(): $ModContainer
public "includeReports"(): boolean
public "getExistingFileHelper"(): $ExistingFileHelper
get "generator"(): $DataGenerator
get "inputs"(): $Collection<($Path)>
get "mods"(): $Set<(string)>
get "lookupProvider"(): $CompletableFuture<($HolderLookup$Provider)>
get "modContainer"(): $ModContainer
get "existingFileHelper"(): $ExistingFileHelper
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GatherDataEvent$$Type = ($GatherDataEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GatherDataEvent_ = $GatherDataEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.ModifyRegistriesEvent" {
import {$Iterable, $Iterable$$Type} from "java.lang.Iterable"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $ModifyRegistriesEvent extends $Event implements $IModBusEvent {


public "getRegistry"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $Registry<(T)>
public "getRegistries"(): $Iterable<($Registry<(any)>)>
get "registries"(): $Iterable<($Registry<(any)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifyRegistriesEvent$$Type = ($ModifyRegistriesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifyRegistriesEvent_ = $ModifyRegistriesEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IItemExtension" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$List, $List$$Type} from "java.util.List"
import {$ItemAttributeModifiers, $ItemAttributeModifiers$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ItemAbility, $ItemAbility$$Type} from "net.neoforged.neoforge.common.ItemAbility"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$FoodProperties, $FoodProperties$$Type} from "net.minecraft.world.food.FoodProperties"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ArmorMaterial$Layer, $ArmorMaterial$Layer$$Type} from "net.minecraft.world.item.ArmorMaterial$Layer"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ItemEnchantments, $ItemEnchantments$$Type} from "net.minecraft.world.item.enchantment.ItemEnchantments"
import {$EquipmentSlot, $EquipmentSlot$$Type} from "net.minecraft.world.entity.EquipmentSlot"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$UseOnContext, $UseOnContext$$Type} from "net.minecraft.world.item.context.UseOnContext"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$RecipeType, $RecipeType$$Type} from "net.minecraft.world.item.crafting.RecipeType"
import {$HolderLookup$RegistryLookup, $HolderLookup$RegistryLookup$$Type} from "net.minecraft.core.HolderLookup$RegistryLookup"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$EnderMan, $EnderMan$$Type} from "net.minecraft.world.entity.monster.EnderMan"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$InteractionResult, $InteractionResult$$Type} from "net.minecraft.world.InteractionResult"
import {$Enchantment, $Enchantment$$Type} from "net.minecraft.world.item.enchantment.Enchantment"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$EnchantmentInstance, $EnchantmentInstance$$Type} from "net.minecraft.world.item.enchantment.EnchantmentInstance"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$AABB, $AABB$$Type} from "net.minecraft.world.phys.AABB"

export interface $IItemExtension {

 "getDamage"(arg0: $ItemStack$$Type): integer
 "isDamaged"(arg0: $ItemStack$$Type): boolean
 "damageItem"<T extends $LivingEntity>(arg0: $ItemStack$$Type, arg1: integer, arg2: T, arg3: $Consumer$$Type<($Item)>): integer
 "setDamage"(arg0: $ItemStack$$Type, arg1: integer): void
 "canEquip"(arg0: $ItemStack$$Type, arg1: $EquipmentSlot$$Type, arg2: $LivingEntity$$Type): boolean
 "getMaxDamage"(arg0: $ItemStack$$Type): integer
 "onAnimalArmorTick"(arg0: $ItemStack$$Type, arg1: $Level$$Type, arg2: $Mob$$Type): void
 "shouldCauseBlockBreakReset"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
 "getEnchantmentLevel"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): integer
 "getEnchantmentValue"(arg0: $ItemStack$$Type): integer
 "makesPiglinsNeutral"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "canGrindstoneRepair"(arg0: $ItemStack$$Type): boolean
 "supportsEnchantment"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): boolean
 "hasCraftingRemainingItem"(arg0: $ItemStack$$Type): boolean
 "getCraftingRemainingItem"(arg0: $ItemStack$$Type): $ItemStack
 "getEquipmentSlot"(arg0: $ItemStack$$Type): $EquipmentSlot
 "getSweepHitBox"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $Entity$$Type): $AABB
 "canDisableShield"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: $LivingEntity$$Type, arg3: $LivingEntity$$Type): boolean
 "canElytraFly"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "elytraFlightTick"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: integer): boolean
 "canContinueUsing"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
/**
 * 
 * @deprecated
 */
 "onEntitySwing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "onEntitySwing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $InteractionHand$$Type): boolean
 "canBeHurtBy"(arg0: $ItemStack$$Type, arg1: $DamageSource$$Type): boolean
 "onEntityItemUpdate"(arg0: $ItemStack$$Type, arg1: $ItemEntity$$Type): boolean
 "getFoodProperties"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): $FoodProperties
 "onDestroyed"(arg0: $ItemEntity$$Type, arg1: $DamageSource$$Type): void
 "onStopUsing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: integer): void
 "getEntityLifespan"(arg0: $ItemStack$$Type, arg1: $Level$$Type): integer
 "isDamageable"(arg0: $ItemStack$$Type): boolean
 "onLeftClickEntity"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $Entity$$Type): boolean
 "getCreatorModId"(arg0: $ItemStack$$Type): string
 "getArmorTexture"(arg0: $ItemStack$$Type, arg1: $Entity$$Type, arg2: $EquipmentSlot$$Type, arg3: $ArmorMaterial$Layer$$Type, arg4: boolean): $ResourceLocation
 "hasCustomEntity"(arg0: $ItemStack$$Type): boolean
 "createEntity"(arg0: $Level$$Type, arg1: $Entity$$Type, arg2: $ItemStack$$Type): $Entity
 "getMaxStackSize"(arg0: $ItemStack$$Type): integer
 "getBurnTime"(arg0: $ItemStack$$Type, arg1: $RecipeType$$Type<(any)>): integer
 "applyEnchantments"(arg0: $ItemStack$$Type, arg1: $List$$Type<($EnchantmentInstance$$Type)>): $ItemStack
 "doesSneakBypassUse"(arg0: $ItemStack$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): boolean
 "isEnderMask"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $EnderMan$$Type): boolean
 "getAllEnchantments"(arg0: $ItemStack$$Type, arg1: $HolderLookup$RegistryLookup$$Type<($Enchantment$$Type)>): $ItemEnchantments
 "onDroppedByPlayer"(arg0: $ItemStack$$Type, arg1: $Player$$Type): boolean
 "isBookEnchantable"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
 "isPrimaryItemFor"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): boolean
 "isRepairable"(arg0: $ItemStack$$Type): boolean
 "getXpRepairRatio"(arg0: $ItemStack$$Type): float
 "isPiglinCurrency"(arg0: $ItemStack$$Type): boolean
 "onItemUseFirst"(arg0: $ItemStack$$Type, arg1: $UseOnContext$$Type): $InteractionResult
 "getHighlightTip"(arg0: $ItemStack$$Type, arg1: $Component$$Type): $Component
 "isNotReplaceableByPickAction"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: integer): boolean
 "getDefaultAttributeModifiers"(arg0: $ItemStack$$Type): $ItemAttributeModifiers
 "canPerformAction"(arg0: $ItemStack$$Type, arg1: $ItemAbility$$Type): boolean
 "canWalkOnPowderedSnow"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "shouldCauseReequipAnimation"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: boolean): boolean

(arg0: $ItemStack): boolean
}

export namespace $IItemExtension {
const probejs$$marker: never
}
export class $IItemExtension$$Static implements $IItemExtension {


 "getDamage"(arg0: $ItemStack$$Type): integer
 "isDamaged"(arg0: $ItemStack$$Type): boolean
 "damageItem"<T extends $LivingEntity>(arg0: $ItemStack$$Type, arg1: integer, arg2: T, arg3: $Consumer$$Type<($Item)>): integer
 "setDamage"(arg0: $ItemStack$$Type, arg1: integer): void
 "canEquip"(arg0: $ItemStack$$Type, arg1: $EquipmentSlot$$Type, arg2: $LivingEntity$$Type): boolean
 "getMaxDamage"(arg0: $ItemStack$$Type): integer
 "onAnimalArmorTick"(arg0: $ItemStack$$Type, arg1: $Level$$Type, arg2: $Mob$$Type): void
 "shouldCauseBlockBreakReset"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
 "getEnchantmentLevel"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): integer
 "getEnchantmentValue"(arg0: $ItemStack$$Type): integer
 "makesPiglinsNeutral"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "canGrindstoneRepair"(arg0: $ItemStack$$Type): boolean
 "supportsEnchantment"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): boolean
 "hasCraftingRemainingItem"(arg0: $ItemStack$$Type): boolean
 "getCraftingRemainingItem"(arg0: $ItemStack$$Type): $ItemStack
 "getEquipmentSlot"(arg0: $ItemStack$$Type): $EquipmentSlot
 "getSweepHitBox"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $Entity$$Type): $AABB
 "canDisableShield"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: $LivingEntity$$Type, arg3: $LivingEntity$$Type): boolean
 "canElytraFly"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "elytraFlightTick"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: integer): boolean
 "canContinueUsing"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
/**
 * 
 * @deprecated
 */
 "onEntitySwing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "onEntitySwing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: $InteractionHand$$Type): boolean
 "canBeHurtBy"(arg0: $ItemStack$$Type, arg1: $DamageSource$$Type): boolean
 "onEntityItemUpdate"(arg0: $ItemStack$$Type, arg1: $ItemEntity$$Type): boolean
 "getFoodProperties"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): $FoodProperties
 "onDestroyed"(arg0: $ItemEntity$$Type, arg1: $DamageSource$$Type): void
 "onStopUsing"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type, arg2: integer): void
 "getEntityLifespan"(arg0: $ItemStack$$Type, arg1: $Level$$Type): integer
 "isDamageable"(arg0: $ItemStack$$Type): boolean
 "onLeftClickEntity"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $Entity$$Type): boolean
 "getCreatorModId"(arg0: $ItemStack$$Type): string
 "getArmorTexture"(arg0: $ItemStack$$Type, arg1: $Entity$$Type, arg2: $EquipmentSlot$$Type, arg3: $ArmorMaterial$Layer$$Type, arg4: boolean): $ResourceLocation
 "hasCustomEntity"(arg0: $ItemStack$$Type): boolean
 "createEntity"(arg0: $Level$$Type, arg1: $Entity$$Type, arg2: $ItemStack$$Type): $Entity
 "getMaxStackSize"(arg0: $ItemStack$$Type): integer
 "getBurnTime"(arg0: $ItemStack$$Type, arg1: $RecipeType$$Type<(any)>): integer
 "applyEnchantments"(arg0: $ItemStack$$Type, arg1: $List$$Type<($EnchantmentInstance$$Type)>): $ItemStack
 "doesSneakBypassUse"(arg0: $ItemStack$$Type, arg1: $LevelReader$$Type, arg2: $BlockPos$$Type, arg3: $Player$$Type): boolean
 "isEnderMask"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: $EnderMan$$Type): boolean
 "getAllEnchantments"(arg0: $ItemStack$$Type, arg1: $HolderLookup$RegistryLookup$$Type<($Enchantment$$Type)>): $ItemEnchantments
 "onDroppedByPlayer"(arg0: $ItemStack$$Type, arg1: $Player$$Type): boolean
 "isBookEnchantable"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): boolean
 "isPrimaryItemFor"(arg0: $ItemStack$$Type, arg1: $Holder$$Type<($Enchantment)>): boolean
 "isRepairable"(arg0: $ItemStack$$Type): boolean
 "getXpRepairRatio"(arg0: $ItemStack$$Type): float
 "isPiglinCurrency"(arg0: $ItemStack$$Type): boolean
 "onItemUseFirst"(arg0: $ItemStack$$Type, arg1: $UseOnContext$$Type): $InteractionResult
 "getHighlightTip"(arg0: $ItemStack$$Type, arg1: $Component$$Type): $Component
 "isNotReplaceableByPickAction"(arg0: $ItemStack$$Type, arg1: $Player$$Type, arg2: integer): boolean
 "getDefaultAttributeModifiers"(arg0: $ItemStack$$Type): $ItemAttributeModifiers
 "canPerformAction"(arg0: $ItemStack$$Type, arg1: $ItemAbility$$Type): boolean
 "canWalkOnPowderedSnow"(arg0: $ItemStack$$Type, arg1: $LivingEntity$$Type): boolean
 "shouldCauseReequipAnimation"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type, arg2: boolean): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IItemExtension$$Type = ((arg0: $ItemStack) => boolean);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IItemExtension_ = $IItemExtension$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.nodes.PermissionNode" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$PermissionDynamicContextKey, $PermissionDynamicContextKey$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionDynamicContextKey"
import {$PermissionNode$PermissionResolver, $PermissionNode$PermissionResolver$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionNode$PermissionResolver"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$PermissionType, $PermissionType$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionType"

export class $PermissionNode<T> {

constructor(arg0: $ResourceLocation$$Type, arg1: $PermissionType$$Type<(T)>, arg2: $PermissionNode$PermissionResolver$$Type<(T)>, ...arg3: ($PermissionDynamicContextKey$$Type<(any)>)[])
constructor(arg0: string, arg1: string, arg2: $PermissionType$$Type<(T)>, arg3: $PermissionNode$PermissionResolver$$Type<(T)>, ...arg4: ($PermissionDynamicContextKey$$Type<(any)>)[])

public "getDescription"(): $Component
public "equals"(arg0: any): boolean
public "hashCode"(): integer
public "getType"(): $PermissionType<(T)>
public "getNodeName"(): string
public "getDynamics"(): ($PermissionDynamicContextKey<(any)>)[]
public "setInformation"(arg0: $Component$$Type, arg1: $Component$$Type): $PermissionNode<(any)>
public "getDefaultResolver"(): $PermissionNode$PermissionResolver<(T)>
public "getReadableName"(): $Component
get "description"(): $Component
get "type"(): $PermissionType<(T)>
get "nodeName"(): string
get "dynamics"(): ($PermissionDynamicContextKey<(any)>)[]
get "defaultResolver"(): $PermissionNode$PermissionResolver<(T)>
get "readableName"(): $Component
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionNode$$Type<T> = ($PermissionNode<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionNode_<T> = $PermissionNode$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingExperienceDropEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingExperienceDropEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $Player$$Type, arg2: integer)

public "getDroppedExperience"(): integer
public "getAttackingPlayer"(): $Player
public "setDroppedExperience"(arg0: integer): void
public "getOriginalExperience"(): integer
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "droppedExperience"(): integer
get "attackingPlayer"(): $Player
set "droppedExperience"(value: integer)
get "originalExperience"(): integer
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingExperienceDropEvent$$Type = ($LivingExperienceDropEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingExperienceDropEvent_ = $LivingExperienceDropEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.IItemDecorator" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"

export interface $IItemDecorator {

 "render"(arg0: $GuiGraphics$$Type, arg1: $Font$$Type, arg2: $ItemStack$$Type, arg3: integer, arg4: integer): boolean

(arg0: $GuiGraphics, arg1: $Font, arg2: $ItemStack, arg3: integer, arg4: integer): boolean
}

export namespace $IItemDecorator {
const probejs$$marker: never
}
export class $IItemDecorator$$Static implements $IItemDecorator {


 "render"(arg0: $GuiGraphics$$Type, arg1: $Font$$Type, arg2: $ItemStack$$Type, arg3: integer, arg4: integer): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IItemDecorator$$Type = ((arg0: $GuiGraphics, arg1: $Font, arg2: $ItemStack, arg3: integer, arg4: integer) => boolean);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IItemDecorator_ = $IItemDecorator$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableStructureInfo" {
import {$Structure, $Structure$$Type} from "net.minecraft.world.level.levelgen.structure.Structure"
import {$List, $List$$Type} from "java.util.List"
import {$ModifiableStructureInfo$StructureInfo, $ModifiableStructureInfo$StructureInfo$$Type} from "net.neoforged.neoforge.common.world.ModifiableStructureInfo$StructureInfo"
import {$StructureModifier, $StructureModifier$$Type} from "net.neoforged.neoforge.common.world.StructureModifier"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $ModifiableStructureInfo {

constructor(arg0: $ModifiableStructureInfo$StructureInfo$$Type)

public "getOriginalStructureInfo"(): $ModifiableStructureInfo$StructureInfo
public "get"(): $ModifiableStructureInfo$StructureInfo
public "applyStructureModifiers"(arg0: $Holder$$Type<($Structure)>, arg1: $List$$Type<($StructureModifier$$Type)>): void
public "getModifiedStructureInfo"(): $ModifiableStructureInfo$StructureInfo
get "originalStructureInfo"(): $ModifiableStructureInfo$StructureInfo
get "modifiedStructureInfo"(): $ModifiableStructureInfo$StructureInfo
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableStructureInfo$$Type = ($ModifiableStructureInfo);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableStructureInfo_ = $ModifiableStructureInfo$$Type;
}}
declare module "net.neoforged.neoforge.common.MutableDataComponentHolder" {
import {$Potion, $Potion$$Type} from "net.minecraft.world.item.alchemy.Potion"
import {$ComponentFunctions, $ComponentFunctions$$Type} from "dev.latvian.mods.kubejs.component.ComponentFunctions"
import {$DataComponentMap, $DataComponentMap$$Type} from "net.minecraft.core.component.DataComponentMap"
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$ItemAttributeModifiers$Entry, $ItemAttributeModifiers$Entry$$Type} from "net.minecraft.world.item.component.ItemAttributeModifiers$Entry"
import {$List, $List$$Type} from "java.util.List"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$DataComponentType, $DataComponentType$$Type} from "net.minecraft.core.component.DataComponentType"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$DyeColor, $DyeColor$$Type} from "net.minecraft.world.item.DyeColor"
import {$MutableDataComponentHolderFunctions, $MutableDataComponentHolderFunctions$$Type} from "dev.latvian.mods.kubejs.component.MutableDataComponentHolderFunctions"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$TooltipProvider, $TooltipProvider$$Type} from "net.minecraft.world.item.component.TooltipProvider"
import {$PotionContents, $PotionContents$$Type} from "net.minecraft.world.item.alchemy.PotionContents"
import {$UnaryOperator, $UnaryOperator$$Type} from "java.util.function.UnaryOperator"
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$Map, $Map$$Type} from "java.util.Map"
import {$Rarity, $Rarity$$Type} from "net.minecraft.world.item.Rarity"
import {$LootTable, $LootTable$$Type} from "net.minecraft.world.level.storage.loot.LootTable"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$Item$TooltipContext, $Item$TooltipContext$$Type} from "net.minecraft.world.item.Item$TooltipContext"
import {$DataComponentHolder, $DataComponentHolder$$Type} from "net.minecraft.core.component.DataComponentHolder"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$BiFunction, $BiFunction$$Type} from "java.util.function.BiFunction"
import {$DataComponentPatch, $DataComponentPatch$$Type} from "net.minecraft.core.component.DataComponentPatch"
import {$KubeColor, $KubeColor$$Type} from "dev.latvian.mods.kubejs.color.KubeColor"
import {$GameProfile, $GameProfile$$Type} from "com.mojang.authlib.GameProfile"
import {$Unit, $Unit$$Type} from "net.minecraft.util.Unit"

export interface $MutableDataComponentHolder extends $DataComponentHolder, $MutableDataComponentHolderFunctions {

 "update"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
 "update"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
 "update"<T, U>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
 "update"<T, U>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
 "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($Supplier$$Type<($DataComponentType$$Type<(any)>)>)[]): void
 "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($DataComponentType$$Type<(any)>)[]): void
 "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
 "getOrDefault"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T): T
 "has"(arg0: $DataComponentType$$Type<(any)>): boolean
 "getComponents"(): $DataComponentMap
 "patch"(arg1: $DataComponentPatch$$Type): $ComponentFunctions
 "set"(arg1: $DataComponentMap$$Type): $MutableDataComponentHolderFunctions
 "getComponentHolder"(): $MutableDataComponentHolder
 "getComponentMap"(): $DataComponentMap
 "get"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>): T
 "getOrDefault"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): T
 "has"(arg0: $Supplier$$Type<($DataComponentType$$Type<(any)>)>): boolean
 "addToTooltip"<T extends $TooltipProvider>(arg0: $DataComponentType$$Type<(T)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "addToTooltip"<T extends $TooltipProvider>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "set"(arg1: $DataComponentType$$Type<(any)>, arg2: any): $ComponentFunctions
 "remove"(arg0: $DataComponentType$$Type<(any)>): $ComponentFunctions
 "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
 "resetComponents"(): $ComponentFunctions
 "setTooltipHidden"(): void
 "getComponentString"(): string
 "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>, arg1: long): void
 "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>): void
 "setAttributeModifiers"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
 "setPotionContents"(arg0: $PotionContents$$Type): void
 "setCustomModelData"(arg0: integer): void
 "setGlintOverride"(arg0: boolean): void
 "getCustomName"(): $Component
 "setDyedColor"(arg0: $KubeColor$$Type): void
 "setEntityData"(arg0: $CompoundTag$$Type): void
 "setProfile"(arg0: $GameProfile$$Type): void
 "setProfile"(arg0: string, arg1: $UUID$$Type): void
 "setLockCode"(arg0: string): void
 "setPotionId"(arg0: $Holder$$Type<($Potion)>): void
 "setLore"(arg0: $List$$Type<($Component$$Type)>, arg1: $List$$Type<($Component$$Type)>): void
 "setLore"(arg0: $List$$Type<($Component$$Type)>): void
 "setBaseColor"(arg0: $DyeColor$$Type): void
 "setCustomData"(arg0: $CompoundTag$$Type): void
 "getCustomData"(): $CompoundTag
 "setRarity"(arg0: $Rarity$$Type): void
 "setCustomName"(arg0: $Component$$Type): void
 "setUnit"(arg0: $DataComponentType$$Type<($Unit$$Type)>): $ComponentFunctions
 "setAttributeModifiersWithTooltip"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
 "setAdditionalTooltipHidden"(): void
 "setBlockStateProperties"(arg0: $Map$$Type<(string), (string)>): void
 "setDyedColorWithTooltip"(arg0: $KubeColor$$Type): void

(): $DataComponentMap$$Type
get "components"(): $DataComponentMap
get "componentHolder"(): $MutableDataComponentHolder
get "componentMap"(): $DataComponentMap
get "componentString"(): string
set "containerLootTable"(value: $ResourceKey$$Type<($LootTable)>)
set "attributeModifiers"(value: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>)
set "potionContents"(value: $PotionContents$$Type)
set "customModelData"(value: integer)
set "glintOverride"(value: boolean)
get "customName"(): $Component
set "dyedColor"(value: $KubeColor$$Type)
set "entityData"(value: $CompoundTag$$Type)
set "profile"(value: $GameProfile$$Type)
set "lockCode"(value: string)
set "potionId"(value: $Holder$$Type<($Potion)>)
set "lore"(value: $List$$Type<($Component$$Type)>)
set "baseColor"(value: $DyeColor$$Type)
set "customData"(value: $CompoundTag$$Type)
get "customData"(): $CompoundTag
set "rarity"(value: $Rarity$$Type)
set "customName"(value: $Component$$Type)
set "unit"(value: $DataComponentType$$Type<($Unit$$Type)>)
set "attributeModifiersWithTooltip"(value: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>)
set "blockStateProperties"(value: $Map$$Type<(string), (string)>)
set "dyedColorWithTooltip"(value: $KubeColor$$Type)
}

export namespace $MutableDataComponentHolder {
const probejs$$marker: never
}
export class $MutableDataComponentHolder$$Static implements $MutableDataComponentHolder {


 "update"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
 "update"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: $UnaryOperator$$Type<(T)>): T
 "update"<T, U>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
 "update"<T, U>(arg0: $DataComponentType$$Type<(T)>, arg1: T, arg2: U, arg3: $BiFunction$$Type<(T), (U), (T)>): T
 "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($Supplier$$Type<($DataComponentType$$Type<(any)>)>)[]): void
 "copyFrom"(arg0: $DataComponentHolder$$Type, ...arg1: ($DataComponentType$$Type<(any)>)[]): void
 "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
 "getOrDefault"<T>(arg0: $DataComponentType$$Type<(T)>, arg1: T): T
 "has"(arg0: $DataComponentType$$Type<(any)>): boolean
 "getComponents"(): $DataComponentMap
 "patch"(arg1: $DataComponentPatch$$Type): $ComponentFunctions
 "set"(arg1: $DataComponentMap$$Type): $MutableDataComponentHolderFunctions
 "getComponentHolder"(): $MutableDataComponentHolder
 "getComponentMap"(): $DataComponentMap
 "get"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>): T
 "getOrDefault"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): T
 "has"(arg0: $Supplier$$Type<($DataComponentType$$Type<(any)>)>): boolean
 "addToTooltip"<T extends $TooltipProvider>(arg0: $DataComponentType$$Type<(T)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "addToTooltip"<T extends $TooltipProvider>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: $Item$TooltipContext$$Type, arg2: $Consumer$$Type<($Component)>, arg3: $TooltipFlag$$Type): void
 "set"(arg1: $DataComponentType$$Type<(any)>, arg2: any): $ComponentFunctions
 "remove"(arg0: $DataComponentType$$Type<(any)>): $ComponentFunctions
 "get"<T>(arg0: $DataComponentType$$Type<(T)>): T
 "resetComponents"(): $ComponentFunctions
 "setTooltipHidden"(): void
 "getComponentString"(): string
 "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>, arg1: long): void
 "setContainerLootTable"(arg0: $ResourceKey$$Type<($LootTable)>): void
 "setAttributeModifiers"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
 "setPotionContents"(arg0: $PotionContents$$Type): void
 "setCustomModelData"(arg0: integer): void
 "setGlintOverride"(arg0: boolean): void
 "getCustomName"(): $Component
 "setDyedColor"(arg0: $KubeColor$$Type): void
 "setEntityData"(arg0: $CompoundTag$$Type): void
 "setProfile"(arg0: $GameProfile$$Type): void
 "setProfile"(arg0: string, arg1: $UUID$$Type): void
 "setLockCode"(arg0: string): void
 "setPotionId"(arg0: $Holder$$Type<($Potion)>): void
 "setLore"(arg0: $List$$Type<($Component$$Type)>, arg1: $List$$Type<($Component$$Type)>): void
 "setLore"(arg0: $List$$Type<($Component$$Type)>): void
 "setBaseColor"(arg0: $DyeColor$$Type): void
 "setCustomData"(arg0: $CompoundTag$$Type): void
 "getCustomData"(): $CompoundTag
 "setRarity"(arg0: $Rarity$$Type): void
 "setCustomName"(arg0: $Component$$Type): void
 "setUnit"(arg0: $DataComponentType$$Type<($Unit$$Type)>): $ComponentFunctions
 "setAttributeModifiersWithTooltip"(arg0: $List$$Type<($ItemAttributeModifiers$Entry$$Type)>): void
 "setAdditionalTooltipHidden"(): void
 "setBlockStateProperties"(arg0: $Map$$Type<(string), (string)>): void
 "setDyedColorWithTooltip"(arg0: $KubeColor$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MutableDataComponentHolder$$Type = (() => $DataComponentMap$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MutableDataComponentHolder_ = $MutableDataComponentHolder$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModFileInfo$LanguageSpec" {
import {$VersionRange, $VersionRange$$Type} from "org.apache.maven.artifact.versioning.VersionRange"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $IModFileInfo$LanguageSpec extends $Record {

constructor(languageName: string, acceptedVersions: $VersionRange$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "languageName"(): string
public "acceptedVersions"(): $VersionRange
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModFileInfo$LanguageSpec$$Type = ({"languageName"?: string, "acceptedVersions"?: $VersionRange$$Type}) | ([languageName?: string, acceptedVersions?: $VersionRange$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModFileInfo$LanguageSpec_ = $IModFileInfo$LanguageSpec$$Type;
}}
declare module "net.neoforged.neoforge.fluids.BaseFlowingFluid$Properties" {
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$LiquidBlock, $LiquidBlock$$Type} from "net.minecraft.world.level.block.LiquidBlock"

export class $BaseFlowingFluid$Properties {

constructor(arg0: $Supplier$$Type<($FluidType$$Type)>, arg1: $Supplier$$Type<($Fluid$$Type)>, arg2: $Supplier$$Type<($Fluid$$Type)>)

public "block"(arg0: $Supplier$$Type<($LiquidBlock$$Type)>): $BaseFlowingFluid$Properties
public "levelDecreasePerBlock"(arg0: integer): $BaseFlowingFluid$Properties
public "explosionResistance"(arg0: float): $BaseFlowingFluid$Properties
public "slopeFindDistance"(arg0: integer): $BaseFlowingFluid$Properties
public "bucket"(arg0: $Supplier$$Type<($Item$$Type)>): $BaseFlowingFluid$Properties
public "tickRate"(arg0: integer): $BaseFlowingFluid$Properties
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BaseFlowingFluid$Properties$$Type = ($BaseFlowingFluid$Properties);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BaseFlowingFluid$Properties_ = $BaseFlowingFluid$Properties$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ITransformationExtension" {
import {$Transformation, $Transformation$$Type} from "com.mojang.math.Transformation"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Vector4f, $Vector4f$$Type} from "org.joml.Vector4f"
import {$Vector3f, $Vector3f$$Type} from "org.joml.Vector3f"

export interface $ITransformationExtension {

 "isIdentity"(): boolean
 "rotateTransform"(arg0: $Direction$$Type): $Direction
 "applyOrigin"(arg0: $Vector3f$$Type): $Transformation
 "transformNormal"(arg0: $Vector3f$$Type): void
 "transformPosition"(arg0: $Vector4f$$Type): void
 "blockCenterToCorner"(): $Transformation
 "blockCornerToCenter"(): $Transformation
get "identity"(): boolean
}

export namespace $ITransformationExtension {
const probejs$$marker: never
}
export class $ITransformationExtension$$Static implements $ITransformationExtension {


 "isIdentity"(): boolean
 "rotateTransform"(arg0: $Direction$$Type): $Direction
 "applyOrigin"(arg0: $Vector3f$$Type): $Transformation
 "transformNormal"(arg0: $Vector3f$$Type): void
 "transformPosition"(arg0: $Vector4f$$Type): void
 "blockCenterToCorner"(): $Transformation
 "blockCornerToCenter"(): $Transformation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ITransformationExtension$$Type = ($ITransformationExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ITransformationExtension_ = $ITransformationExtension$$Type;
}}
declare module "net.neoforged.fml.common.asm.enumextension.IExtensibleEnum" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export interface $IExtensibleEnum {

}

export namespace $IExtensibleEnum {
const probejs$$marker: never
}
export class $IExtensibleEnum$$Static implements $IExtensibleEnum {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IExtensibleEnum$$Type = ($IExtensibleEnum);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IExtensibleEnum_ = $IExtensibleEnum$$Type;
}}
declare module "net.neoforged.api.distmarker.Dist" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $Dist extends $Enum<($Dist)> {
static readonly "DEDICATED_SERVER": $Dist
static readonly "CLIENT": $Dist


public static "values"(): ($Dist)[]
public static "valueOf"(arg0: string): $Dist
public "isDedicatedServer"(): boolean
public "isClient"(): boolean
get "dedicatedServer"(): boolean
get "client"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Dist$$Type = (("client") | ("dedicated_server"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Dist_ = $Dist$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ILevelExtension" {
import {$BlockCapability, $BlockCapability$$Type} from "net.neoforged.neoforge.capabilities.BlockCapability"
import {$ModelDataManager, $ModelDataManager$$Type} from "net.neoforged.neoforge.client.model.data.ModelDataManager"
import {$PartEntity, $PartEntity$$Type} from "net.neoforged.neoforge.entity.PartEntity"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$ChunkPos, $ChunkPos$$Type} from "net.minecraft.world.level.ChunkPos"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $ILevelExtension {

 "getDescription"(): $Component
 "getCapability"<T>(arg0: $BlockCapability$$Type<(T), (void)>, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type): T
 "getCapability"<T, C>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: C): T
 "getCapability"<T, C>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $BlockPos$$Type, arg2: C): T
 "getCapability"<T>(arg0: $BlockCapability$$Type<(T), (void)>, arg1: $BlockPos$$Type): T
 "increaseMaxEntityRadius"(arg0: double): double
 "invalidateCapabilities"(arg0: $ChunkPos$$Type): void
 "invalidateCapabilities"(arg0: $BlockPos$$Type): void
 "getModelDataManager"(): $ModelDataManager
 "getPartEntities"(): $Collection<($PartEntity<(any)>)>
 "getMaxEntityRadius"(): double
 "getDescriptionKey"(): string
get "description"(): $Component
get "modelDataManager"(): $ModelDataManager
get "partEntities"(): $Collection<($PartEntity<(any)>)>
get "maxEntityRadius"(): double
get "descriptionKey"(): string
}

export namespace $ILevelExtension {
const TRANSLATION_PREFIX: string
const probejs$$marker: never
}
export class $ILevelExtension$$Static implements $ILevelExtension {
static readonly "TRANSLATION_PREFIX": string


 "getDescription"(): $Component
 "getCapability"<T>(arg0: $BlockCapability$$Type<(T), (void)>, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type): T
 "getCapability"<T, C>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: C): T
 "getCapability"<T, C>(arg0: $BlockCapability$$Type<(T), (C)>, arg1: $BlockPos$$Type, arg2: C): T
 "getCapability"<T>(arg0: $BlockCapability$$Type<(T), (void)>, arg1: $BlockPos$$Type): T
 "increaseMaxEntityRadius"(arg0: double): double
 "invalidateCapabilities"(arg0: $ChunkPos$$Type): void
 "invalidateCapabilities"(arg0: $BlockPos$$Type): void
 "getModelDataManager"(): $ModelDataManager
 "getPartEntities"(): $Collection<($PartEntity<(any)>)>
 "getMaxEntityRadius"(): double
 "getDescriptionKey"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ILevelExtension$$Type = ($ILevelExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ILevelExtension_ = $ILevelExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.ChunkRenderTypeSet" {
import {$Iterable, $Iterable$$Type} from "java.lang.Iterable"
import {$Iterator, $Iterator$$Type} from "java.util.Iterator"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Spliterator, $Spliterator$$Type} from "java.util.Spliterator"
import {$List, $List$$Type} from "java.util.List"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $ChunkRenderTypeSet implements $Iterable<($RenderType)> {


public "isEmpty"(): boolean
public "iterator"(): $Iterator<($RenderType)>
public static "of"(...arg0: ($RenderType$$Type)[]): $ChunkRenderTypeSet
public static "of"(arg0: $Collection$$Type<($RenderType$$Type)>): $ChunkRenderTypeSet
public "contains"(arg0: $RenderType$$Type): boolean
public "asList"(): $List<($RenderType)>
public static "all"(): $ChunkRenderTypeSet
public static "union"(arg0: $Collection$$Type<($ChunkRenderTypeSet$$Type)>): $ChunkRenderTypeSet
public static "union"(arg0: $Iterable$$Type<($ChunkRenderTypeSet$$Type)>): $ChunkRenderTypeSet
public static "union"(...arg0: ($ChunkRenderTypeSet$$Type)[]): $ChunkRenderTypeSet
public static "none"(): $ChunkRenderTypeSet
public static "intersection"(...arg0: ($ChunkRenderTypeSet$$Type)[]): $ChunkRenderTypeSet
public static "intersection"(arg0: $Iterable$$Type<($ChunkRenderTypeSet$$Type)>): $ChunkRenderTypeSet
public static "intersection"(arg0: $Collection$$Type<($ChunkRenderTypeSet$$Type)>): $ChunkRenderTypeSet
public "spliterator"(): $Spliterator<($RenderType)>
public "forEach"(arg0: $Consumer$$Type<($RenderType)>): void
[Symbol.iterator](): IterableIterator<$RenderType>;
get "empty"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ChunkRenderTypeSet$$Type = ($ChunkRenderTypeSet);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ChunkRenderTypeSet_ = $ChunkRenderTypeSet$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.LevelTickEvent$Post" {
import {$LevelTickEvent, $LevelTickEvent$$Type} from "net.neoforged.neoforge.event.tick.LevelTickEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BooleanSupplier, $BooleanSupplier$$Type} from "java.util.function.BooleanSupplier"

export class $LevelTickEvent$Post extends $LevelTickEvent {

constructor(arg0: $BooleanSupplier$$Type, arg1: $Level$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelTickEvent$Post$$Type = ($LevelTickEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelTickEvent$Post_ = $LevelTickEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ArrowNockEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$InteractionResultHolder, $InteractionResultHolder$$Type} from "net.minecraft.world.InteractionResultHolder"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $ArrowNockEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $InteractionHand$$Type, arg3: $Level$$Type, arg4: boolean)

public "getLevel"(): $Level
public "setAction"(arg0: $InteractionResultHolder$$Type<($ItemStack$$Type)>): void
public "hasAmmo"(): boolean
public "getBow"(): $ItemStack
public "getAction"(): $InteractionResultHolder<($ItemStack)>
public "getHand"(): $InteractionHand
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "level"(): $Level
set "action"(value: $InteractionResultHolder$$Type<($ItemStack$$Type)>)
get "bow"(): $ItemStack
get "action"(): $InteractionResultHolder<($ItemStack)>
get "hand"(): $InteractionHand
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ArrowNockEvent$$Type = ($ArrowNockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ArrowNockEvent_ = $ArrowNockEvent$$Type;
}}
declare module "net.neoforged.neoforge.fluids.crafting.SizedFluidIngredient" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$SizedFluidIngredientKJS, $SizedFluidIngredientKJS$$Type} from "dev.latvian.mods.kubejs.core.SizedFluidIngredientKJS"
import {$TagKey, $TagKey$$Type} from "net.minecraft.tags.TagKey"
import {$FluidStack, $FluidStack$$Type} from "net.neoforged.neoforge.fluids.FluidStack"
import {$FluidIngredient, $FluidIngredient$$Type} from "net.neoforged.neoforge.fluids.crafting.FluidIngredient"

export class $SizedFluidIngredient implements $SizedFluidIngredientKJS {
static readonly "NESTED_CODEC": $Codec<($SizedFluidIngredient)>
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($SizedFluidIngredient)>
static readonly "FLAT_CODEC": $Codec<($SizedFluidIngredient)>

constructor(arg0: $FluidIngredient$$Type, arg1: integer)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: $FluidStack$$Type): boolean
public static "of"(arg0: $Fluid$$Type, arg1: integer): $SizedFluidIngredient
public static "of"(arg0: $TagKey$$Type<($Fluid)>, arg1: integer): $SizedFluidIngredient
public static "of"(arg0: $FluidStack$$Type): $SizedFluidIngredient
public "amount"(): integer
public "ingredient"(): $FluidIngredient
public "getFluids"(): ($FluidStack)[]
public "matches"(arg1: $FluidIngredient$$Type, arg2: boolean): boolean
public "matches"(arg1: $FluidStack$$Type, arg2: boolean): boolean
public "self"(): $SizedFluidIngredient
public "replaceThisWith"(arg1: any): any
public static "wrap"(arg1: any): $ReplacementMatch
get "fluids"(): ($FluidStack)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SizedFluidIngredient$$Type = ($SizedFluidIngredient);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SizedFluidIngredient_ = $SizedFluidIngredient$$Type;
}}
declare module "net.neoforged.neoforge.client.gui.map.IMapDecorationRenderer" {
import {$MapDecorationTextureManager, $MapDecorationTextureManager$$Type} from "net.minecraft.client.resources.MapDecorationTextureManager"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$MapDecoration, $MapDecoration$$Type} from "net.minecraft.world.level.saveddata.maps.MapDecoration"
import {$MapItemSavedData, $MapItemSavedData$$Type} from "net.minecraft.world.level.saveddata.maps.MapItemSavedData"

export interface $IMapDecorationRenderer {

 "render"(arg0: $MapDecoration$$Type, arg1: $PoseStack$$Type, arg2: $MultiBufferSource$$Type, arg3: $MapItemSavedData$$Type, arg4: $MapDecorationTextureManager$$Type, arg5: boolean, arg6: integer, arg7: integer): boolean

(arg0: $MapDecoration, arg1: $PoseStack, arg2: $MultiBufferSource, arg3: $MapItemSavedData, arg4: $MapDecorationTextureManager, arg5: boolean, arg6: integer, arg7: integer): boolean
}

export namespace $IMapDecorationRenderer {
const probejs$$marker: never
}
export class $IMapDecorationRenderer$$Static implements $IMapDecorationRenderer {


 "render"(arg0: $MapDecoration$$Type, arg1: $PoseStack$$Type, arg2: $MultiBufferSource$$Type, arg3: $MapItemSavedData$$Type, arg4: $MapDecorationTextureManager$$Type, arg5: boolean, arg6: integer, arg7: integer): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMapDecorationRenderer$$Type = ((arg0: $MapDecoration, arg1: $PoseStack, arg2: $MultiBufferSource, arg3: $MapItemSavedData, arg4: $MapDecorationTextureManager, arg5: boolean, arg6: integer, arg7: integer) => boolean);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMapDecorationRenderer_ = $IMapDecorationRenderer$$Type;
}}
declare module "net.neoforged.neoforgespi.language.IModInfo" {
import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
import {$Map, $Map$$Type} from "java.util.Map"
import {$IModFileInfo, $IModFileInfo$$Type} from "net.neoforged.neoforgespi.language.IModFileInfo"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$IModInfo$ModVersion, $IModInfo$ModVersion$$Type} from "net.neoforged.neoforgespi.language.IModInfo$ModVersion"
import {$IConfigurable, $IConfigurable$$Type} from "net.neoforged.neoforgespi.language.IConfigurable"
import {$List, $List$$Type} from "java.util.List"
import {$URL, $URL$$Type} from "java.net.URL"
import {$ForgeFeature$Bound, $ForgeFeature$Bound$$Type} from "net.neoforged.neoforgespi.locating.ForgeFeature$Bound"
import {$VersionRange, $VersionRange$$Type} from "org.apache.maven.artifact.versioning.VersionRange"
import {$IModLanguageLoader, $IModLanguageLoader$$Type} from "net.neoforged.neoforgespi.language.IModLanguageLoader"

export interface $IModInfo {

 "getDescription"(): string
 "getLoader"(): $IModLanguageLoader
 "getDisplayName"(): string
 "getVersion"(): $ArtifactVersion
 "getNamespace"(): string
 "getConfig"(): $IConfigurable
 "getModId"(): string
 "getOwningFile"(): $IModFileInfo
 "getModProperties"(): $Map<(string), (any)>
 "getUpdateURL"(): $Optional<($URL)>
 "getLogoFile"(): $Optional<(string)>
 "getDependencies"(): $List<($IModInfo$ModVersion)>
 "getLogoBlur"(): boolean
 "getForgeFeatures"(): $List<($ForgeFeature$Bound)>
 "getModURL"(): $Optional<($URL)>
get "description"(): string
get "loader"(): $IModLanguageLoader
get "displayName"(): string
get "version"(): $ArtifactVersion
get "namespace"(): string
get "config"(): $IConfigurable
get "modId"(): string
get "owningFile"(): $IModFileInfo
get "modProperties"(): $Map<(string), (any)>
get "updateURL"(): $Optional<($URL)>
get "logoFile"(): $Optional<(string)>
get "dependencies"(): $List<($IModInfo$ModVersion)>
get "logoBlur"(): boolean
get "forgeFeatures"(): $List<($ForgeFeature$Bound)>
get "modURL"(): $Optional<($URL)>
}

export namespace $IModInfo {
const UNBOUNDED: $VersionRange
const probejs$$marker: never
}
export class $IModInfo$$Static implements $IModInfo {
static readonly "UNBOUNDED": $VersionRange


 "getDescription"(): string
 "getLoader"(): $IModLanguageLoader
 "getDisplayName"(): string
 "getVersion"(): $ArtifactVersion
 "getNamespace"(): string
 "getConfig"(): $IConfigurable
 "getModId"(): string
 "getOwningFile"(): $IModFileInfo
 "getModProperties"(): $Map<(string), (any)>
 "getUpdateURL"(): $Optional<($URL)>
 "getLogoFile"(): $Optional<(string)>
 "getDependencies"(): $List<($IModInfo$ModVersion)>
 "getLogoBlur"(): boolean
 "getForgeFeatures"(): $List<($ForgeFeature$Bound)>
 "getModURL"(): $Optional<($URL)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModInfo$$Type = ($IModInfo);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModInfo_ = $IModInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"

export class $LivingEntityUseItemEvent extends $LivingEvent {


public "getDuration"(): integer
public "getItem"(): $ItemStack
public "setDuration"(arg0: integer): void
get "duration"(): integer
get "item"(): $ItemStack
set "duration"(value: integer)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEntityUseItemEvent$$Type = ($LivingEntityUseItemEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEntityUseItemEvent_ = $LivingEntityUseItemEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ModelEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ModelEvent extends $Event {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelEvent$$Type = ($ModelEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelEvent_ = $ModelEvent$$Type;
}}
declare module "net.neoforged.bus.api.EventPriority" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $EventPriority extends $Enum<($EventPriority)> {
static readonly "LOWEST": $EventPriority
static readonly "HIGH": $EventPriority
static readonly "LOW": $EventPriority
static readonly "HIGHEST": $EventPriority
static readonly "NORMAL": $EventPriority


public static "values"(): ($EventPriority)[]
public static "valueOf"(arg0: string): $EventPriority
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EventPriority$$Type = (("highest") | ("high") | ("normal") | ("low") | ("lowest"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EventPriority_ = $EventPriority$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.IGuiGraphicsExtension" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Font, $Font$$Type} from "net.minecraft.client.gui.Font"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export interface $IGuiGraphicsExtension {

 "drawScrollingString"(arg0: $Font$$Type, arg1: $Component$$Type, arg2: integer, arg3: integer, arg4: integer, arg5: integer): integer
 "getColorFromFormattingCharacter"(arg0: character, arg1: boolean): integer
 "blitWithBorder"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: integer, arg10: integer, arg11: integer, arg12: integer): void
 "blitWithBorder"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
 "blitInscribed"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: boolean, arg8: boolean): void
 "blitInscribed"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
}

export namespace $IGuiGraphicsExtension {
const DEFAULT_BORDER_COLOR_START: integer
const TEXT_COLOR_CODES: (integer)[]
const UNDO_CHAR: string
const DEFAULT_BACKGROUND_COLOR: integer
const VALID: string
const DEFAULT_BORDER_COLOR_END: integer
const INVALID: string
const RESET_CHAR: string
const probejs$$marker: never
}
export class $IGuiGraphicsExtension$$Static implements $IGuiGraphicsExtension {
static readonly "DEFAULT_BORDER_COLOR_START": integer
static readonly "TEXT_COLOR_CODES": (integer)[]
static readonly "UNDO_CHAR": string
static readonly "DEFAULT_BACKGROUND_COLOR": integer
static readonly "VALID": string
static readonly "DEFAULT_BORDER_COLOR_END": integer
static readonly "INVALID": string
static readonly "RESET_CHAR": string


 "drawScrollingString"(arg0: $Font$$Type, arg1: $Component$$Type, arg2: integer, arg3: integer, arg4: integer, arg5: integer): integer
 "getColorFromFormattingCharacter"(arg0: character, arg1: boolean): integer
 "blitWithBorder"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: integer, arg10: integer, arg11: integer, arg12: integer): void
 "blitWithBorder"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
 "blitInscribed"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: boolean, arg8: boolean): void
 "blitInscribed"(arg0: $ResourceLocation$$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IGuiGraphicsExtension$$Type = ($IGuiGraphicsExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IGuiGraphicsExtension_ = $IGuiGraphicsExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.AddReloadListenerEvent" {
import {$ICondition$IContext, $ICondition$IContext$$Type} from "net.neoforged.neoforge.common.conditions.ICondition$IContext"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PreparableReloadListener, $PreparableReloadListener$$Type} from "net.minecraft.server.packs.resources.PreparableReloadListener"
import {$ReloadableServerResources, $ReloadableServerResources$$Type} from "net.minecraft.server.ReloadableServerResources"
import {$RegistryAccess, $RegistryAccess$$Type} from "net.minecraft.core.RegistryAccess"

export class $AddReloadListenerEvent extends $Event {

constructor(arg0: $ReloadableServerResources$$Type, arg1: $RegistryAccess$$Type)

public "getListeners"(): $List<($PreparableReloadListener)>
public "getConditionContext"(): $ICondition$IContext
public "addListener"(arg0: $PreparableReloadListener$$Type): void
public "getServerResources"(): $ReloadableServerResources
public "getRegistryAccess"(): $RegistryAccess
get "listeners"(): $List<($PreparableReloadListener)>
get "conditionContext"(): $ICondition$IContext
get "serverResources"(): $ReloadableServerResources
get "registryAccess"(): $RegistryAccess
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddReloadListenerEvent$$Type = ($AddReloadListenerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddReloadListenerEvent_ = $AddReloadListenerEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBucketPickupExtension" {
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IBucketPickupExtension {

 "getPickupSound"(arg0: $BlockState$$Type): $Optional<($SoundEvent)>
}

export namespace $IBucketPickupExtension {
const probejs$$marker: never
}
export class $IBucketPickupExtension$$Static implements $IBucketPickupExtension {


 "getPickupSound"(arg0: $BlockState$$Type): $Optional<($SoundEvent)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBucketPickupExtension$$Type = ($IBucketPickupExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBucketPickupExtension_ = $IBucketPickupExtension$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingConversionEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingConversionEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingConversionEvent$$Type = ($LivingConversionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingConversionEvent_ = $LivingConversionEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerWakeUpEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerWakeUpEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: boolean, arg2: boolean)

public "wakeImmediately"(): boolean
public "updateLevel"(): boolean
public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerWakeUpEvent$$Type = ($PlayerWakeUpEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerWakeUpEvent_ = $PlayerWakeUpEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.AnimalTameEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$Animal, $Animal$$Type} from "net.minecraft.world.entity.animal.Animal"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"

export class $AnimalTameEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $Animal$$Type, arg1: $Player$$Type)

public "getTamer"(): $Player
public "getAnimal"(): $Animal
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "tamer"(): $Player
get "animal"(): $Animal
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnimalTameEvent$$Type = ($AnimalTameEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnimalTameEvent_ = $AnimalTameEvent$$Type;
}}
declare module "net.neoforged.neoforge.network.bundle.PacketAndPayloadAcceptor" {
import {$ClientCommonPacketListener, $ClientCommonPacketListener$$Type} from "net.minecraft.network.protocol.common.ClientCommonPacketListener"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $PacketAndPayloadAcceptor<L extends $ClientCommonPacketListener> {

constructor(arg0: $Consumer$$Type<($Packet<(L)>)>)

public "accept"(arg0: $Packet$$Type<(L)>): $PacketAndPayloadAcceptor<(L)>
public "accept"(arg0: $CustomPacketPayload$$Type): $PacketAndPayloadAcceptor<(L)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PacketAndPayloadAcceptor$$Type<L> = ($PacketAndPayloadAcceptor<(L)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PacketAndPayloadAcceptor_<L> = $PacketAndPayloadAcceptor$$Type<(L)>;
}}
declare module "net.neoforged.neoforge.event.level.ExplosionEvent$Start" {
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ExplosionEvent, $ExplosionEvent$$Type} from "net.neoforged.neoforge.event.level.ExplosionEvent"

export class $ExplosionEvent$Start extends $ExplosionEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $Explosion$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExplosionEvent$Start$$Type = ($ExplosionEvent$Start);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExplosionEvent$Start_ = $ExplosionEvent$Start$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDropsEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingDropsEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageSource$$Type, arg2: $Collection$$Type<($ItemEntity$$Type)>, arg3: boolean)

public "getSource"(): $DamageSource
public "isRecentlyHit"(): boolean
public "getDrops"(): $Collection<($ItemEntity)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "source"(): $DamageSource
get "recentlyHit"(): boolean
get "drops"(): $Collection<($ItemEntity)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDropsEvent$$Type = ($LivingDropsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDropsEvent_ = $LivingDropsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseScrolled$Post" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseScrolled, $ScreenEvent$MouseScrolled$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseScrolled"

export class $ScreenEvent$MouseScrolled$Post extends $ScreenEvent$MouseScrolled {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: double, arg4: double)

public "getMouseY"(): double
public "getMouseX"(): double
get "mouseY"(): double
get "mouseX"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseScrolled$Post$$Type = ($ScreenEvent$MouseScrolled$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseScrolled$Post_ = $ScreenEvent$MouseScrolled$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingShieldBlockEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingShieldBlockEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageContainer$$Type, arg2: boolean)

public "shieldDamage"(): float
public "setBlockedDamage"(arg0: float): void
public "getBlockedDamage"(): float
public "getDamageContainer"(): $DamageContainer
public "getBlocked"(): boolean
public "getOriginalBlockedDamage"(): float
public "getDamageSource"(): $DamageSource
public "getOriginalBlock"(): boolean
public "setShieldDamage"(arg0: float): void
public "setBlocked"(arg0: boolean): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "blockedDamage"(value: float)
get "blockedDamage"(): float
get "damageContainer"(): $DamageContainer
get "blocked"(): boolean
get "originalBlockedDamage"(): float
get "damageSource"(): $DamageSource
get "originalBlock"(): boolean
set "blocked"(value: boolean)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingShieldBlockEvent$$Type = ($LivingShieldBlockEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingShieldBlockEvent_ = $LivingShieldBlockEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.GrindstoneEvent" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $GrindstoneEvent extends $Event {


public "getXp"(): integer
public "getBottomItem"(): $ItemStack
public "getTopItem"(): $ItemStack
public "setXp"(arg0: integer): void
get "xp"(): integer
get "bottomItem"(): $ItemStack
get "topItem"(): $ItemStack
set "xp"(value: integer)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GrindstoneEvent$$Type = ($GrindstoneEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GrindstoneEvent_ = $GrindstoneEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.server.ServerStartingEvent" {
import {$ServerLifecycleEvent, $ServerLifecycleEvent$$Type} from "net.neoforged.neoforge.event.server.ServerLifecycleEvent"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerStartingEvent extends $ServerLifecycleEvent {

constructor(arg0: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerStartingEvent$$Type = ($ServerStartingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerStartingEvent_ = $ServerStartingEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.RegisterSpawnPlacementsEvent" {
import {$RegisterSpawnPlacementsEvent$Operation, $RegisterSpawnPlacementsEvent$Operation$$Type} from "net.neoforged.neoforge.event.entity.RegisterSpawnPlacementsEvent$Operation"
import {$RegisterSpawnPlacementsEvent$MergedSpawnPredicate, $RegisterSpawnPlacementsEvent$MergedSpawnPredicate$$Type} from "net.neoforged.neoforge.event.entity.RegisterSpawnPlacementsEvent$MergedSpawnPredicate"
import {$Map, $Map$$Type} from "java.util.Map"
import {$Heightmap$Types, $Heightmap$Types$$Type} from "net.minecraft.world.level.levelgen.Heightmap$Types"
import {$SpawnPlacements$SpawnPredicate, $SpawnPlacements$SpawnPredicate$$Type} from "net.minecraft.world.entity.SpawnPlacements$SpawnPredicate"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$SpawnPlacementType, $SpawnPlacementType$$Type} from "net.minecraft.world.entity.SpawnPlacementType"
import {$EntityType, $EntityType$$Type} from "net.minecraft.world.entity.EntityType"

export class $RegisterSpawnPlacementsEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($EntityType$$Type<(any)>), ($RegisterSpawnPlacementsEvent$MergedSpawnPredicate$$Type<(any)>)>)

public "register"<T extends $Entity>(arg0: $EntityType$$Type<(T)>, arg1: $SpawnPlacementType$$Type, arg2: $Heightmap$Types$$Type, arg3: $SpawnPlacements$SpawnPredicate$$Type<(T)>, arg4: $RegisterSpawnPlacementsEvent$Operation$$Type): void
public "register"<T extends $Entity>(arg0: $EntityType$$Type<(T)>, arg1: $SpawnPlacements$SpawnPredicate$$Type<(T)>, arg2: $RegisterSpawnPlacementsEvent$Operation$$Type): void
public "register"<T extends $Entity>(arg0: $EntityType$$Type<(T)>, arg1: $SpawnPlacements$SpawnPredicate$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterSpawnPlacementsEvent$$Type = ($RegisterSpawnPlacementsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterSpawnPlacementsEvent_ = $RegisterSpawnPlacementsEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiLayerEvent" {
import {$LayeredDraw$Layer, $LayeredDraw$Layer$$Type} from "net.minecraft.client.gui.LayeredDraw$Layer"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiLayerEvent extends $Event {


public "getName"(): $ResourceLocation
public "getLayer"(): $LayeredDraw$Layer
public "getGuiGraphics"(): $GuiGraphics
public "getPartialTick"(): $DeltaTracker
get "name"(): $ResourceLocation
get "layer"(): $LayeredDraw$Layer
get "guiGraphics"(): $GuiGraphics
get "partialTick"(): $DeltaTracker
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiLayerEvent$$Type = ($RenderGuiLayerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiLayerEvent_ = $RenderGuiLayerEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.model.geometry.BlockGeometryBakingContext$VisibilityData" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export class $BlockGeometryBakingContext$VisibilityData {

constructor()

public "copyFrom"(arg0: $BlockGeometryBakingContext$VisibilityData$$Type): void
public "setVisibilityState"(arg0: string, arg1: boolean): void
public "isVisible"(arg0: string, arg1: boolean): boolean
public "hasCustomVisibility"(arg0: string): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockGeometryBakingContext$VisibilityData$$Type = ($BlockGeometryBakingContext$VisibilityData);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockGeometryBakingContext$VisibilityData_ = $BlockGeometryBakingContext$VisibilityData$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent$Load" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent$Load extends $LevelEvent {

constructor(arg0: $LevelAccessor$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$Load$$Type = ($LevelEvent$Load);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent$Load_ = $LevelEvent$Load$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$ItemSmeltedEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerEvent$ItemSmeltedEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type)

public "getEntity"(): $Entity
public "getSmelting"(): $ItemStack
get "entity"(): $Entity
get "smelting"(): $ItemStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$ItemSmeltedEvent$$Type = ($PlayerEvent$ItemSmeltedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$ItemSmeltedEvent_ = $PlayerEvent$ItemSmeltedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ModelEvent$BakingCompleted" {
import {$ModelEvent, $ModelEvent$$Type} from "net.neoforged.neoforge.client.event.ModelEvent"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ModelResourceLocation, $ModelResourceLocation$$Type} from "net.minecraft.client.resources.model.ModelResourceLocation"
import {$BakedModel, $BakedModel$$Type} from "net.minecraft.client.resources.model.BakedModel"
import {$ModelBakery, $ModelBakery$$Type} from "net.minecraft.client.resources.model.ModelBakery"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$ModelManager, $ModelManager$$Type} from "net.minecraft.client.resources.model.ModelManager"

export class $ModelEvent$BakingCompleted extends $ModelEvent implements $IModBusEvent {

constructor(arg0: $ModelManager$$Type, arg1: $Map$$Type<($ModelResourceLocation$$Type), ($BakedModel$$Type)>, arg2: $ModelBakery$$Type)

public "getModels"(): $Map<($ModelResourceLocation), ($BakedModel)>
public "getModelBakery"(): $ModelBakery
public "getModelManager"(): $ModelManager
get "models"(): $Map<($ModelResourceLocation), ($BakedModel)>
get "modelBakery"(): $ModelBakery
get "modelManager"(): $ModelManager
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelEvent$BakingCompleted$$Type = ($ModelEvent$BakingCompleted);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelEvent$BakingCompleted_ = $ModelEvent$BakingCompleted$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AdvancementEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$AdvancementHolder, $AdvancementHolder$$Type} from "net.minecraft.advancements.AdvancementHolder"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $AdvancementEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $AdvancementHolder$$Type)

public "getAdvancement"(): $AdvancementHolder
public "getEntity"(): $Entity
get "advancement"(): $AdvancementHolder
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AdvancementEvent$$Type = ($AdvancementEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AdvancementEvent_ = $AdvancementEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.ServerTickEvent$Post" {
import {$BooleanSupplier, $BooleanSupplier$$Type} from "java.util.function.BooleanSupplier"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"
import {$ServerTickEvent, $ServerTickEvent$$Type} from "net.neoforged.neoforge.event.tick.ServerTickEvent"

export class $ServerTickEvent$Post extends $ServerTickEvent {

constructor(arg0: $BooleanSupplier$$Type, arg1: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerTickEvent$Post$$Type = ($ServerTickEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerTickEvent$Post_ = $ServerTickEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityTeleportEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityTeleportEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Entity$$Type, arg1: double, arg2: double, arg3: double)

public "getTarget"(): $Vec3
public "getPrevX"(): double
public "setTargetZ"(arg0: double): void
public "getPrevZ"(): double
public "setTargetY"(arg0: double): void
public "getPrev"(): $Vec3
public "setTargetX"(arg0: double): void
public "getPrevY"(): double
public "getTargetX"(): double
public "getTargetZ"(): double
public "getTargetY"(): double
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "target"(): $Vec3
get "prevX"(): double
set "targetZ"(value: double)
get "prevZ"(): double
set "targetY"(value: double)
get "prev"(): $Vec3
set "targetX"(value: double)
get "prevY"(): double
get "targetX"(): double
get "targetZ"(): double
get "targetY"(): double
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTeleportEvent$$Type = ($EntityTeleportEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTeleportEvent_ = $EntityTeleportEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerRespawnPositionEvent" {
import {$DimensionTransition, $DimensionTransition$$Type} from "net.minecraft.world.level.portal.DimensionTransition"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerRespawnPositionEvent extends $PlayerEvent {

constructor(arg0: $ServerPlayer$$Type, arg1: $DimensionTransition$$Type, arg2: boolean)

public "getOriginalDimensionTransition"(): $DimensionTransition
public "setCopyOriginalSpawnPosition"(arg0: boolean): void
public "setRespawnLevel"(arg0: $ResourceKey$$Type<($Level)>): void
public "isFromEndFight"(): boolean
public "copyOriginalSpawnPosition"(): boolean
public "setDimensionTransition"(arg0: $DimensionTransition$$Type): void
public "getDimensionTransition"(): $DimensionTransition
public "getEntity"(): $Entity
get "originalDimensionTransition"(): $DimensionTransition
set "respawnLevel"(value: $ResourceKey$$Type<($Level)>)
get "fromEndFight"(): boolean
set "dimensionTransition"(value: $DimensionTransition$$Type)
get "dimensionTransition"(): $DimensionTransition
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerRespawnPositionEvent$$Type = ($PlayerRespawnPositionEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerRespawnPositionEvent_ = $PlayerRespawnPositionEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.AddSectionGeometryEvent$SectionRenderingContext" {
import {$QuadLighter, $QuadLighter$$Type} from "net.neoforged.neoforge.client.model.lighting.QuadLighter"
import {$BlockAndTintGetter, $BlockAndTintGetter$$Type} from "net.minecraft.world.level.BlockAndTintGetter"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Function, $Function$$Type} from "java.util.function.Function"
import {$VertexConsumer, $VertexConsumer$$Type} from "com.mojang.blaze3d.vertex.VertexConsumer"
import {$RenderType, $RenderType$$Type} from "net.minecraft.client.renderer.RenderType"

export class $AddSectionGeometryEvent$SectionRenderingContext {

constructor(arg0: $Function$$Type<($RenderType), ($VertexConsumer$$Type)>, arg1: $BlockAndTintGetter$$Type, arg2: $PoseStack$$Type)

public "getRegion"(): $BlockAndTintGetter
public "getQuadLighter"(arg0: boolean): $QuadLighter
public "getPoseStack"(): $PoseStack
public "getOrCreateChunkBuffer"(arg0: $RenderType$$Type): $VertexConsumer
get "region"(): $BlockAndTintGetter
get "poseStack"(): $PoseStack
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddSectionGeometryEvent$SectionRenderingContext$$Type = ($AddSectionGeometryEvent$SectionRenderingContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddSectionGeometryEvent$SectionRenderingContext_ = $AddSectionGeometryEvent$SectionRenderingContext$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderHighlightEvent$Block" {
import {$BlockHitResult, $BlockHitResult$$Type} from "net.minecraft.world.phys.BlockHitResult"
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$RenderHighlightEvent, $RenderHighlightEvent$$Type} from "net.neoforged.neoforge.client.event.RenderHighlightEvent"
import {$LevelRenderer, $LevelRenderer$$Type} from "net.minecraft.client.renderer.LevelRenderer"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"

export class $RenderHighlightEvent$Block extends $RenderHighlightEvent implements $ICancellableEvent {

constructor(arg0: $LevelRenderer$$Type, arg1: $Camera$$Type, arg2: $BlockHitResult$$Type, arg3: $DeltaTracker$$Type, arg4: $PoseStack$$Type, arg5: $MultiBufferSource$$Type)

public "getTarget"(): $BlockHitResult
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "target"(): $BlockHitResult
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderHighlightEvent$Block$$Type = ($RenderHighlightEvent$Block);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderHighlightEvent$Block_ = $RenderHighlightEvent$Block$$Type;
}}
declare module "net.neoforged.neoforge.event.RegisterStructureConversionsEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$StructuresBecomeConfiguredFix$Conversion, $StructuresBecomeConfiguredFix$Conversion$$Type} from "net.minecraft.util.datafix.fixes.StructuresBecomeConfiguredFix$Conversion"

export class $RegisterStructureConversionsEvent extends $Event {

constructor(arg0: $Map$$Type<(string), ($StructuresBecomeConfiguredFix$Conversion$$Type)>)

public "register"(arg0: string, arg1: $StructuresBecomeConfiguredFix$Conversion$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterStructureConversionsEvent$$Type = ($RegisterStructureConversionsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterStructureConversionsEvent_ = $RegisterStructureConversionsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.ModMismatchEvent" {
import {$ArtifactVersion, $ArtifactVersion$$Type} from "org.apache.maven.artifact.versioning.ArtifactVersion"
import {$Map, $Map$$Type} from "java.util.Map"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$ModMismatchEvent$MismatchResolutionResult, $ModMismatchEvent$MismatchResolutionResult$$Type} from "net.neoforged.neoforge.event.ModMismatchEvent$MismatchResolutionResult"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$ModMismatchEvent$MismatchedVersionInfo, $ModMismatchEvent$MismatchedVersionInfo$$Type} from "net.neoforged.neoforge.event.ModMismatchEvent$MismatchedVersionInfo"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$LevelStorageSource$LevelDirectory, $LevelStorageSource$LevelDirectory$$Type} from "net.minecraft.world.level.storage.LevelStorageSource$LevelDirectory"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"
import {$ModContainer, $ModContainer$$Type} from "net.neoforged.fml.ModContainer"

export class $ModMismatchEvent extends $Event implements $IModBusEvent {

constructor(arg0: $LevelStorageSource$LevelDirectory$$Type, arg1: $Map$$Type<(string), ($ArtifactVersion$$Type)>, arg2: $Map$$Type<(string), ($ArtifactVersion$$Type)>)

public "getResolved"(): $Stream<($ModMismatchEvent$MismatchResolutionResult)>
public "getCurrentVersion"(arg0: string): $ArtifactVersion
public "getVersionDifference"(arg0: string): $Optional<($ModMismatchEvent$MismatchedVersionInfo)>
public "getLevelDirectory"(): $LevelStorageSource$LevelDirectory
public "getPreviousVersion"(arg0: string): $ArtifactVersion
public "wasResolved"(arg0: string): boolean
public "getResolver"(arg0: string): $Optional<($ModContainer)>
public "anyUnresolved"(): boolean
public "getUnresolved"(): $Stream<($ModMismatchEvent$MismatchResolutionResult)>
public "anyResolved"(): boolean
public "markResolved"(arg0: string): void
get "resolved"(): $Stream<($ModMismatchEvent$MismatchResolutionResult)>
get "levelDirectory"(): $LevelStorageSource$LevelDirectory
get "unresolved"(): $Stream<($ModMismatchEvent$MismatchResolutionResult)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModMismatchEvent$$Type = ($ModMismatchEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModMismatchEvent_ = $ModMismatchEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPauseChangeEvent$Post" {
import {$ClientPauseChangeEvent, $ClientPauseChangeEvent$$Type} from "net.neoforged.neoforge.client.event.ClientPauseChangeEvent"

export class $ClientPauseChangeEvent$Post extends $ClientPauseChangeEvent {

constructor(arg0: boolean)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPauseChangeEvent$Post$$Type = ($ClientPauseChangeEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPauseChangeEvent$Post_ = $ClientPauseChangeEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterGuiLayersEvent" {
import {$LayeredDraw$Layer, $LayeredDraw$Layer$$Type} from "net.minecraft.client.gui.LayeredDraw$Layer"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$GuiLayerManager$NamedLayer, $GuiLayerManager$NamedLayer$$Type} from "net.neoforged.neoforge.client.gui.GuiLayerManager$NamedLayer"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterGuiLayersEvent extends $Event implements $IModBusEvent {

constructor(arg0: $List$$Type<($GuiLayerManager$NamedLayer$$Type)>)

public "registerBelowAll"(arg0: $ResourceLocation$$Type, arg1: $LayeredDraw$Layer$$Type): void
public "registerBelow"(arg0: $ResourceLocation$$Type, arg1: $ResourceLocation$$Type, arg2: $LayeredDraw$Layer$$Type): void
public "registerAboveAll"(arg0: $ResourceLocation$$Type, arg1: $LayeredDraw$Layer$$Type): void
public "registerAbove"(arg0: $ResourceLocation$$Type, arg1: $ResourceLocation$$Type, arg2: $LayeredDraw$Layer$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterGuiLayersEvent$$Type = ($RegisterGuiLayersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterGuiLayersEvent_ = $RegisterGuiLayersEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.language.ModFileScanData" {
import {$IModFileInfo, $IModFileInfo$$Type} from "net.neoforged.neoforgespi.language.IModFileInfo"
import {$Annotation, $Annotation$$Type} from "java.lang.annotation.Annotation"
import {$List, $List$$Type} from "java.util.List"
import {$Set, $Set$$Type} from "java.util.Set"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$ModFileScanData$ClassData, $ModFileScanData$ClassData$$Type} from "net.neoforged.neoforgespi.language.ModFileScanData$ClassData"
import {$Stream, $Stream$$Type} from "java.util.stream.Stream"
import {$ElementType, $ElementType$$Type} from "java.lang.annotation.ElementType"
import {$ModFileScanData$AnnotationData, $ModFileScanData$AnnotationData$$Type} from "net.neoforged.neoforgespi.language.ModFileScanData$AnnotationData"

export class $ModFileScanData {

constructor()

public "getClasses"(): $Set<($ModFileScanData$ClassData)>
public "getAnnotations"(): $Set<($ModFileScanData$AnnotationData)>
public "getAnnotatedBy"(arg0: $Class$$Type<($Annotation$$Type)>, arg1: $ElementType$$Type): $Stream<($ModFileScanData$AnnotationData)>
public "getIModInfoData"(): $List<($IModFileInfo)>
public "addModFileInfo"(arg0: $IModFileInfo$$Type): void
get "classes"(): $Set<($ModFileScanData$ClassData)>
get "annotations"(): $Set<($ModFileScanData$AnnotationData)>
get "iModInfoData"(): $List<($IModFileInfo)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFileScanData$$Type = ($ModFileScanData);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFileScanData_ = $ModFileScanData$$Type;
}}
declare module "net.neoforged.neoforge.client.extensions.common.IClientItemExtensions$FontContext" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $IClientItemExtensions$FontContext extends $Enum<($IClientItemExtensions$FontContext)> {
static readonly "TOOLTIP": $IClientItemExtensions$FontContext
static readonly "SELECTED_ITEM_NAME": $IClientItemExtensions$FontContext
static readonly "ITEM_COUNT": $IClientItemExtensions$FontContext


public static "values"(): ($IClientItemExtensions$FontContext)[]
public static "valueOf"(arg0: string): $IClientItemExtensions$FontContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientItemExtensions$FontContext$$Type = (("item_count") | ("tooltip") | ("selected_item_name"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientItemExtensions$FontContext_ = $IClientItemExtensions$FontContext$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobDespawnEvent" {
import {$ServerLevelAccessor, $ServerLevelAccessor$$Type} from "net.minecraft.world.level.ServerLevelAccessor"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$MobSpawnEvent, $MobSpawnEvent$$Type} from "net.neoforged.neoforge.event.entity.living.MobSpawnEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$MobDespawnEvent$Result, $MobDespawnEvent$Result$$Type} from "net.neoforged.neoforge.event.entity.living.MobDespawnEvent$Result"

export class $MobDespawnEvent extends $MobSpawnEvent {

constructor(arg0: $Mob$$Type, arg1: $ServerLevelAccessor$$Type)

public "setResult"(arg0: $MobDespawnEvent$Result$$Type): void
public "getResult"(): $MobDespawnEvent$Result
public "getEntity"(): $Entity
set "result"(value: $MobDespawnEvent$Result$$Type)
get "result"(): $MobDespawnEvent$Result
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobDespawnEvent$$Type = ($MobDespawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobDespawnEvent_ = $MobDespawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$LeftClickBlock$Action" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$ServerboundPlayerActionPacket$Action, $ServerboundPlayerActionPacket$Action$$Type} from "net.minecraft.network.protocol.game.ServerboundPlayerActionPacket$Action"

export class $PlayerInteractEvent$LeftClickBlock$Action extends $Enum<($PlayerInteractEvent$LeftClickBlock$Action)> {
static readonly "ABORT": $PlayerInteractEvent$LeftClickBlock$Action
static readonly "STOP": $PlayerInteractEvent$LeftClickBlock$Action
static readonly "CLIENT_HOLD": $PlayerInteractEvent$LeftClickBlock$Action
static readonly "START": $PlayerInteractEvent$LeftClickBlock$Action


public static "values"(): ($PlayerInteractEvent$LeftClickBlock$Action)[]
public static "convert"(arg0: $ServerboundPlayerActionPacket$Action$$Type): $PlayerInteractEvent$LeftClickBlock$Action
public static "valueOf"(arg0: string): $PlayerInteractEvent$LeftClickBlock$Action
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$LeftClickBlock$Action$$Type = (("start") | ("stop") | ("abort") | ("client_hold"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$LeftClickBlock$Action_ = $PlayerInteractEvent$LeftClickBlock$Action$$Type;
}}
declare module "net.neoforged.neoforge.event.level.block.CreateFluidSourceEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $CreateFluidSourceEvent extends $BlockEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type)

public "canConvert"(): boolean
public "getLevel"(): $LevelAccessor
public "getVanillaResult"(): boolean
public "setCanConvert"(arg0: boolean): void
public "getFluidState"(): $FluidState
get "level"(): $LevelAccessor
get "vanillaResult"(): boolean
get "fluidState"(): $FluidState
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CreateFluidSourceEvent$$Type = ($CreateFluidSourceEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CreateFluidSourceEvent_ = $CreateFluidSourceEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent$Tick" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityUseItemEvent, $LivingEntityUseItemEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEntityUseItemEvent"

export class $LivingEntityUseItemEvent$Tick extends $LivingEntityUseItemEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $ItemStack$$Type, arg2: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEntityUseItemEvent$Tick$$Type = ($LivingEntityUseItemEvent$Tick);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEntityUseItemEvent$Tick_ = $LivingEntityUseItemEvent$Tick$$Type;
}}
declare module "net.neoforged.neoforge.common.ItemAbility" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"

export class $ItemAbility {
static "CODEC": $Codec<($ItemAbility)>


public "name"(): string
public static "get"(arg0: string): $ItemAbility
public "toString"(): string
public static "getActions"(): $Collection<($ItemAbility)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemAbility$$Type = ($ItemAbility);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemAbility_ = $ItemAbility$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IFluidExtension" {
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$Explosion, $Explosion$$Type} from "net.minecraft.world.level.Explosion"
import {$PathType, $PathType$$Type} from "net.minecraft.world.level.pathfinder.PathType"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$Boat, $Boat$$Type} from "net.minecraft.world.entity.vehicle.Boat"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IFluidExtension {

 "move"(arg0: $FluidState$$Type, arg1: $LivingEntity$$Type, arg2: $Vec3$$Type, arg3: double): boolean
 "getExplosionResistance"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): float
 "getAdjacentBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: $PathType$$Type): $PathType
 "canExtinguish"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "canConvertToSource"(arg0: $FluidState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
 "supportsBoating"(arg0: $FluidState$$Type, arg1: $Boat$$Type): boolean
 "getFluidType"(): $FluidType
 "getBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: boolean): $PathType
 "canHydrate"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type): boolean

(): $FluidType$$Type
get "fluidType"(): $FluidType
}

export namespace $IFluidExtension {
const probejs$$marker: never
}
export class $IFluidExtension$$Static implements $IFluidExtension {


 "move"(arg0: $FluidState$$Type, arg1: $LivingEntity$$Type, arg2: $Vec3$$Type, arg3: double): boolean
 "getExplosionResistance"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Explosion$$Type): float
 "getAdjacentBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: $PathType$$Type): $PathType
 "canExtinguish"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "canConvertToSource"(arg0: $FluidState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
 "supportsBoating"(arg0: $FluidState$$Type, arg1: $Boat$$Type): boolean
 "getFluidType"(): $FluidType
 "getBlockPathType"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $Mob$$Type, arg4: boolean): $PathType
 "canHydrate"(arg0: $FluidState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $BlockState$$Type, arg4: $BlockPos$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IFluidExtension$$Type = (() => $FluidType$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IFluidExtension_ = $IFluidExtension$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterColorHandlersEvent extends $Event implements $IModBusEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterColorHandlersEvent$$Type = ($RegisterColorHandlersEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterColorHandlersEvent_ = $RegisterColorHandlersEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.util.BlockSnapshot" {
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockSnapshot {


public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getState"(): $BlockState
public static "create"(arg0: $ResourceKey$$Type<($Level)>, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type): $BlockSnapshot
public static "create"(arg0: $ResourceKey$$Type<($Level)>, arg1: $LevelAccessor$$Type, arg2: $BlockPos$$Type, arg3: integer): $BlockSnapshot
public "getLevel"(): $LevelAccessor
public "getFlags"(): integer
public "getTag"(): $CompoundTag
public "getDimension"(): $ResourceKey<($Level)>
public "restore"(): boolean
public "restore"(arg0: integer): boolean
public "getCurrentState"(): $BlockState
public "getPos"(): $BlockPos
public "restoreBlockEntity"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type): boolean
public "restoreToLocation"(arg0: $LevelAccessor$$Type, arg1: $BlockPos$$Type, arg2: integer): boolean
public "recreateBlockEntity"(arg0: $HolderLookup$Provider$$Type): $BlockEntity
get "state"(): $BlockState
get "level"(): $LevelAccessor
get "flags"(): integer
get "tag"(): $CompoundTag
get "dimension"(): $ResourceKey<($Level)>
get "currentState"(): $BlockState
get "pos"(): $BlockPos
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockSnapshot$$Type = ($BlockSnapshot);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockSnapshot_ = $BlockSnapshot$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.ICommandSourceStackExtension" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$RecipeManager, $RecipeManager$$Type} from "net.minecraft.world.item.crafting.RecipeManager"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$AdvancementHolder, $AdvancementHolder$$Type} from "net.minecraft.advancements.AdvancementHolder"
import {$Scoreboard, $Scoreboard$$Type} from "net.minecraft.world.scores.Scoreboard"

export interface $ICommandSourceStackExtension {

 "getUnsidedLevel"(): $Level
 "getAdvancement"(arg0: $ResourceLocation$$Type): $AdvancementHolder
 "getRecipeManager"(): $RecipeManager
 "getScoreboard"(): $Scoreboard
get "unsidedLevel"(): $Level
get "recipeManager"(): $RecipeManager
get "scoreboard"(): $Scoreboard
}

export namespace $ICommandSourceStackExtension {
const probejs$$marker: never
}
export class $ICommandSourceStackExtension$$Static implements $ICommandSourceStackExtension {


 "getUnsidedLevel"(): $Level
 "getAdvancement"(arg0: $ResourceLocation$$Type): $AdvancementHolder
 "getRecipeManager"(): $RecipeManager
 "getScoreboard"(): $Scoreboard
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICommandSourceStackExtension$$Type = ($ICommandSourceStackExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICommandSourceStackExtension_ = $ICommandSourceStackExtension$$Type;
}}
declare module "net.neoforged.neoforge.registries.holdersets.AnyHolderSet$Type" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ICustomHolderSet, $ICustomHolderSet$$Type} from "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$HolderSetType, $HolderSetType$$Type} from "net.neoforged.neoforge.registries.holdersets.HolderSetType"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $AnyHolderSet$Type implements $HolderSetType {

constructor()

public "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
public "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnyHolderSet$Type$$Type = ($AnyHolderSet$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnyHolderSet$Type_ = $AnyHolderSet$Type$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockEvent$NeighborNotifyEvent" {
import {$BlockEvent, $BlockEvent$$Type} from "net.neoforged.neoforge.event.level.BlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$EnumSet, $EnumSet$$Type} from "java.util.EnumSet"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $BlockEvent$NeighborNotifyEvent extends $BlockEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $EnumSet$$Type<($Direction$$Type)>, arg4: boolean)

public "getNotifiedSides"(): $EnumSet<($Direction)>
public "getForceRedstoneUpdate"(): boolean
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "notifiedSides"(): $EnumSet<($Direction)>
get "forceRedstoneUpdate"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockEvent$NeighborNotifyEvent$$Type = ($BlockEvent$NeighborNotifyEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockEvent$NeighborNotifyEvent_ = $BlockEvent$NeighborNotifyEvent$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.IBlockCapabilityProvider" {
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockEntity, $BlockEntity$$Type} from "net.minecraft.world.level.block.entity.BlockEntity"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IBlockCapabilityProvider<T, C> {

 "getCapability"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: C): T

(arg0: $Level, arg1: $BlockPos, arg2: $BlockState, arg3: $BlockEntity, arg4: C): T
}

export namespace $IBlockCapabilityProvider {
const probejs$$marker: never
}
export class $IBlockCapabilityProvider$$Static<T, C> implements $IBlockCapabilityProvider {


 "getCapability"(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockEntity$$Type, arg4: C): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBlockCapabilityProvider$$Type<T, C> = ((arg0: $Level, arg1: $BlockPos, arg2: $BlockState, arg3: $BlockEntity, arg4: C) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBlockCapabilityProvider_<T, C> = $IBlockCapabilityProvider$$Type<(T), (C)>;
}}
declare module "net.neoforged.neoforge.client.event.RegisterMaterialAtlasesEvent" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $RegisterMaterialAtlasesEvent extends $Event implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceLocation$$Type), ($ResourceLocation$$Type)>)

public "register"(arg0: $ResourceLocation$$Type, arg1: $ResourceLocation$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterMaterialAtlasesEvent$$Type = ($RegisterMaterialAtlasesEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterMaterialAtlasesEvent_ = $RegisterMaterialAtlasesEvent$$Type;
}}
declare module "net.neoforged.neoforge.network.registration.PayloadRegistrar" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$HandlerThread, $HandlerThread$$Type} from "net.neoforged.neoforge.network.registration.HandlerThread"
import {$FriendlyByteBuf, $FriendlyByteBuf$$Type} from "net.minecraft.network.FriendlyByteBuf"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$IPayloadHandler, $IPayloadHandler$$Type} from "net.neoforged.neoforge.network.handling.IPayloadHandler"

export class $PayloadRegistrar {

constructor(arg0: string)

public "playBidirectional"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "commonToClient"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "commonToServer"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "commonBidirectional"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "optional"(): $PayloadRegistrar
public "playToClient"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "executesOn"(arg0: $HandlerThread$$Type): $PayloadRegistrar
public "versioned"(arg0: string): $PayloadRegistrar
public "configurationToServer"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "configurationToClient"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "configurationBidirectional"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($FriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
public "playToServer"<T extends $CustomPacketPayload>(arg0: $CustomPacketPayload$Type$$Type<(T)>, arg1: $StreamCodec$$Type<($RegistryFriendlyByteBuf$$Type), (T)>, arg2: $IPayloadHandler$$Type<(T)>): $PayloadRegistrar
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PayloadRegistrar$$Type = ($PayloadRegistrar);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PayloadRegistrar_ = $PayloadRegistrar$$Type;
}}
declare module "net.neoforged.fml.IExtensionPoint" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export interface $IExtensionPoint {

}

export namespace $IExtensionPoint {
const probejs$$marker: never
}
export class $IExtensionPoint$$Static implements $IExtensionPoint {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IExtensionPoint$$Type = ($IExtensionPoint);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IExtensionPoint_ = $IExtensionPoint$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.EntityEvent$EntityConstructing" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $EntityEvent$EntityConstructing extends $EntityEvent {

constructor(arg0: $Entity$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityEvent$EntityConstructing$$Type = ($EntityEvent$EntityConstructing);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityEvent$EntityConstructing_ = $EntityEvent$EntityConstructing$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiLayerEvent$Pre" {
import {$LayeredDraw$Layer, $LayeredDraw$Layer$$Type} from "net.minecraft.client.gui.LayeredDraw$Layer"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$RenderGuiLayerEvent, $RenderGuiLayerEvent$$Type} from "net.neoforged.neoforge.client.event.RenderGuiLayerEvent"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiLayerEvent$Pre extends $RenderGuiLayerEvent implements $ICancellableEvent {

constructor(arg0: $GuiGraphics$$Type, arg1: $DeltaTracker$$Type, arg2: $ResourceLocation$$Type, arg3: $LayeredDraw$Layer$$Type)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiLayerEvent$Pre$$Type = ($RenderGuiLayerEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiLayerEvent$Pre_ = $RenderGuiLayerEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.common.util.InsertableLinkedOpenCustomHashSet" {
import {$ObjectBidirectionalIterator, $ObjectBidirectionalIterator$$Type} from "it.unimi.dsi.fastutil.objects.ObjectBidirectionalIterator"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Hash$Strategy, $Hash$Strategy$$Type} from "it.unimi.dsi.fastutil.Hash$Strategy"
import {$SequencedSet, $SequencedSet$$Type} from "java.util.SequencedSet"
import {$SortedSet, $SortedSet$$Type} from "java.util.SortedSet"
import {$ObjectSet, $ObjectSet$$Type} from "it.unimi.dsi.fastutil.objects.ObjectSet"
import {$ObjectIterator, $ObjectIterator$$Type} from "it.unimi.dsi.fastutil.objects.ObjectIterator"
import {$Set, $Set$$Type} from "java.util.Set"
import {$ObjectLinkedOpenCustomHashSet, $ObjectLinkedOpenCustomHashSet$$Type} from "it.unimi.dsi.fastutil.objects.ObjectLinkedOpenCustomHashSet"

export class $InsertableLinkedOpenCustomHashSet<T> extends $ObjectLinkedOpenCustomHashSet<(T)> {

constructor()
constructor(arg0: $Hash$Strategy$$Type<(T)>)

public "addFirst"(arg0: T): void
public "addLast"(arg0: T): void
public "addAfter"(arg0: T, arg1: T): boolean
public "addBefore"(arg0: T, arg1: T): boolean
public "iterator"(arg0: any): $ObjectBidirectionalIterator<(any)>
public "iterator"(): $ObjectIterator<(any)>
public "subSet"(arg0: any, arg1: any): $SortedSet<(any)>
public "headSet"(arg0: any): $SortedSet<(any)>
public "tailSet"(arg0: any): $SortedSet<(any)>
public static "of"<K>(arg0: K, arg1: K): $ObjectSet<(K)>
public static "of"<K>(...arg0: (K)[]): $ObjectSet<(K)>
public static "of"<K>(arg0: K, arg1: K, arg2: K): $ObjectSet<(K)>
public static "of"<K>(): $ObjectSet<(K)>
public static "of"<K>(arg0: K): $ObjectSet<(K)>
public "reversed"(): $SequencedSet<(any)>
public static "copyOf"<E>(arg0: $Collection$$Type<(E)>): $Set<(E)>
public "toArray"(): (any)[]
public "toArray"<T>(arg0: (T)[]): (T)[]
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E, arg5: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E, arg5: E, arg6: E, arg7: E, arg8: E, arg9: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E, arg5: E, arg6: E, arg7: E, arg8: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E, arg5: E, arg6: E, arg7: E): $Set<(E)>
public static "of"<E>(arg0: E, arg1: E, arg2: E, arg3: E, arg4: E, arg5: E, arg6: E): $Set<(E)>
public "removeAll"(arg0: $Collection$$Type<(any)>): boolean
public "retainAll"(arg0: $Collection$$Type<(any)>): boolean
public "containsAll"(arg0: $Collection$$Type<(any)>): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InsertableLinkedOpenCustomHashSet$$Type<T> = ($InsertableLinkedOpenCustomHashSet<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InsertableLinkedOpenCustomHashSet_<T> = $InsertableLinkedOpenCustomHashSet$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.level.NoteBlockEvent$Note" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $NoteBlockEvent$Note extends $Enum<($NoteBlockEvent$Note)> {
static readonly "A": $NoteBlockEvent$Note
static readonly "F_SHARP": $NoteBlockEvent$Note
static readonly "B": $NoteBlockEvent$Note
static readonly "C": $NoteBlockEvent$Note
static readonly "D": $NoteBlockEvent$Note
static readonly "E": $NoteBlockEvent$Note
static readonly "F": $NoteBlockEvent$Note
static readonly "G": $NoteBlockEvent$Note
static readonly "G_SHARP": $NoteBlockEvent$Note
static readonly "A_SHARP": $NoteBlockEvent$Note
static readonly "D_SHARP": $NoteBlockEvent$Note
static readonly "C_SHARP": $NoteBlockEvent$Note


public static "values"(): ($NoteBlockEvent$Note)[]
public static "valueOf"(arg0: string): $NoteBlockEvent$Note
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NoteBlockEvent$Note$$Type = (("f_sharp") | ("g") | ("g_sharp") | ("a") | ("a_sharp") | ("b") | ("c") | ("c_sharp") | ("d") | ("d_sharp") | ("e") | ("f"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NoteBlockEvent$Note_ = $NoteBlockEvent$Note$$Type;
}}
declare module "net.neoforged.neoforge.registries.IdMappingEvent$IdRemapping" {
import {$Record, $Record$$Type} from "java.lang.Record"

export class $IdMappingEvent$IdRemapping extends $Record {

constructor(currId: integer, newId: integer)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "newId"(): integer
public "currId"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IdMappingEvent$IdRemapping$$Type = ({"newId"?: integer, "currId"?: integer}) | ([newId?: integer, currId?: integer]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IdMappingEvent$IdRemapping_ = $IdMappingEvent$IdRemapping$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ViewportEvent$RenderFog" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$FogShape, $FogShape$$Type} from "com.mojang.blaze3d.shaders.FogShape"
import {$FogType, $FogType$$Type} from "net.minecraft.world.level.material.FogType"
import {$FogRenderer$FogMode, $FogRenderer$FogMode$$Type} from "net.minecraft.client.renderer.FogRenderer$FogMode"
import {$ViewportEvent, $ViewportEvent$$Type} from "net.neoforged.neoforge.client.event.ViewportEvent"

export class $ViewportEvent$RenderFog extends $ViewportEvent implements $ICancellableEvent {

constructor(arg0: $FogRenderer$FogMode$$Type, arg1: $FogType$$Type, arg2: $Camera$$Type, arg3: float, arg4: float, arg5: float, arg6: $FogShape$$Type)

public "getType"(): $FogType
public "getNearPlaneDistance"(): float
public "getFarPlaneDistance"(): float
public "getMode"(): $FogRenderer$FogMode
public "setFogShape"(arg0: $FogShape$$Type): void
public "scaleFarPlaneDistance"(arg0: float): void
public "scaleNearPlaneDistance"(arg0: float): void
public "setNearPlaneDistance"(arg0: float): void
public "setFarPlaneDistance"(arg0: float): void
public "getFogShape"(): $FogShape
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "type"(): $FogType
get "nearPlaneDistance"(): float
get "farPlaneDistance"(): float
get "mode"(): $FogRenderer$FogMode
set "fogShape"(value: $FogShape$$Type)
set "nearPlaneDistance"(value: float)
set "farPlaneDistance"(value: float)
get "fogShape"(): $FogShape
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ViewportEvent$RenderFog$$Type = ($ViewportEvent$RenderFog);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ViewportEvent$RenderFog_ = $ViewportEvent$RenderFog$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingIncomingDamageEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$IReductionFunction, $IReductionFunction$$Type} from "net.neoforged.neoforge.common.damagesource.IReductionFunction"
import {$DamageContainer$Reduction, $DamageContainer$Reduction$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer$Reduction"

export class $LivingIncomingDamageEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageContainer$$Type)

public "getSource"(): $DamageSource
public "getContainer"(): $DamageContainer
public "getAmount"(): float
public "addReductionModifier"(arg0: $DamageContainer$Reduction$$Type, arg1: $IReductionFunction$$Type): void
public "setInvulnerabilityTicks"(arg0: integer): void
public "getOriginalAmount"(): float
public "setAmount"(arg0: float): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "source"(): $DamageSource
get "container"(): $DamageContainer
get "amount"(): float
set "invulnerabilityTicks"(value: integer)
get "originalAmount"(): float
set "amount"(value: float)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingIncomingDamageEvent$$Type = ($LivingIncomingDamageEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingIncomingDamageEvent_ = $LivingIncomingDamageEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ModelEvent$RegisterGeometryLoaders" {
import {$ModelEvent, $ModelEvent$$Type} from "net.neoforged.neoforge.client.event.ModelEvent"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$IGeometryLoader, $IGeometryLoader$$Type} from "net.neoforged.neoforge.client.model.geometry.IGeometryLoader"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $ModelEvent$RegisterGeometryLoaders extends $ModelEvent implements $IModBusEvent {

constructor(arg0: $Map$$Type<($ResourceLocation$$Type), ($IGeometryLoader$$Type<(any)>)>)

public "register"(arg0: $ResourceLocation$$Type, arg1: $IGeometryLoader$$Type<(any)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModelEvent$RegisterGeometryLoaders$$Type = ($ModelEvent$RegisterGeometryLoaders);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModelEvent$RegisterGeometryLoaders_ = $ModelEvent$RegisterGeometryLoaders$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientPlayerChangeGameTypeEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$PlayerInfo, $PlayerInfo$$Type} from "net.minecraft.client.multiplayer.PlayerInfo"
import {$GameType, $GameType$$Type} from "net.minecraft.world.level.GameType"

export class $ClientPlayerChangeGameTypeEvent extends $Event {

constructor(arg0: $PlayerInfo$$Type, arg1: $GameType$$Type, arg2: $GameType$$Type)

public "getInfo"(): $PlayerInfo
public "getCurrentGameType"(): $GameType
public "getNewGameType"(): $GameType
get "info"(): $PlayerInfo
get "currentGameType"(): $GameType
get "newGameType"(): $GameType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientPlayerChangeGameTypeEvent$$Type = ($ClientPlayerChangeGameTypeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientPlayerChangeGameTypeEvent_ = $ClientPlayerChangeGameTypeEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$Init$Post" {
import {$GuiEventListener, $GuiEventListener$$Type} from "net.minecraft.client.gui.components.events.GuiEventListener"
import {$ScreenEvent$Init, $ScreenEvent$Init$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$Init"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$List, $List$$Type} from "java.util.List"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"

export class $ScreenEvent$Init$Post extends $ScreenEvent$Init {

constructor(arg0: $Screen$$Type, arg1: $List$$Type<($GuiEventListener$$Type)>, arg2: $Consumer$$Type<($GuiEventListener)>, arg3: $Consumer$$Type<($GuiEventListener)>)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$Init$Post$$Type = ($ScreenEvent$Init$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$Init$Post_ = $ScreenEvent$Init$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseDragged$Post" {
import {$ScreenEvent$MouseDragged, $ScreenEvent$MouseDragged$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseDragged"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$MouseDragged$Post extends $ScreenEvent$MouseDragged {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer, arg4: double, arg5: double)

public "getMouseY"(): double
public "getMouseX"(): double
get "mouseY"(): double
get "mouseX"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseDragged$Post$$Type = ($ScreenEvent$MouseDragged$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseDragged$Post_ = $ScreenEvent$MouseDragged$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.level.BlockGrowFeatureEvent" {
import {$RandomSource, $RandomSource$$Type} from "net.minecraft.util.RandomSource"
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$ConfiguredFeature, $ConfiguredFeature$$Type} from "net.minecraft.world.level.levelgen.feature.ConfiguredFeature"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $BlockGrowFeatureEvent extends $LevelEvent implements $ICancellableEvent {

constructor(arg0: $LevelAccessor$$Type, arg1: $RandomSource$$Type, arg2: $BlockPos$$Type, arg3: $Holder$$Type<($ConfiguredFeature<(any), (any)>)>)

public "getFeature"(): $Holder<($ConfiguredFeature<(any), (any)>)>
public "setCanceled"(arg0: boolean): void
public "setFeature"(arg0: $ResourceKey$$Type<($ConfiguredFeature<(any), (any)>)>): void
public "setFeature"(arg0: $Holder$$Type<($ConfiguredFeature<(any), (any)>)>): void
public "getRandom"(): $RandomSource
public "getPos"(): $BlockPos
public "isCanceled"(): boolean
get "feature"(): $Holder<($ConfiguredFeature<(any), (any)>)>
set "canceled"(value: boolean)
set "feature"(value: $ResourceKey$$Type<($ConfiguredFeature<(any), (any)>)>)
set "feature"(value: $Holder$$Type<($ConfiguredFeature<(any), (any)>)>)
get "random"(): $RandomSource
get "pos"(): $BlockPos
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlockGrowFeatureEvent$$Type = ($BlockGrowFeatureEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlockGrowFeatureEvent_ = $BlockGrowFeatureEvent$$Type;
}}
declare module "net.neoforged.neoforge.network.handling.IPayloadContext" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$ConfigurationTask$Type, $ConfigurationTask$Type$$Type} from "net.minecraft.server.network.ConfigurationTask$Type"
import {$Runnable, $Runnable$$Type} from "java.lang.Runnable"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$ChannelHandlerContext, $ChannelHandlerContext$$Type} from "io.netty.channel.ChannelHandlerContext"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$CompletableFuture, $CompletableFuture$$Type} from "java.util.concurrent.CompletableFuture"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$ICommonPacketListener, $ICommonPacketListener$$Type} from "net.neoforged.neoforge.common.extensions.ICommonPacketListener"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"

export interface $IPayloadContext {

 "handle"(arg0: $CustomPacketPayload$$Type): void
 "handle"(arg0: $Packet$$Type<(any)>): void
 "protocol"(): $ConnectionProtocol
 "connection"(): $Connection
 "listener"(): $ICommonPacketListener
 "disconnect"(arg0: $Component$$Type): void
 "enqueueWork"<T>(arg0: $Supplier$$Type<(T)>): $CompletableFuture<(T)>
 "enqueueWork"(arg0: $Runnable$$Type): $CompletableFuture<(void)>
 "player"(): $Player
 "reply"(arg0: $CustomPacketPayload$$Type): void
 "flow"(): $PacketFlow
 "channelHandlerContext"(): $ChannelHandlerContext
 "finishCurrentTask"(arg0: $ConfigurationTask$Type$$Type): void
}

export namespace $IPayloadContext {
const probejs$$marker: never
}
export class $IPayloadContext$$Static implements $IPayloadContext {


 "handle"(arg0: $CustomPacketPayload$$Type): void
 "handle"(arg0: $Packet$$Type<(any)>): void
 "protocol"(): $ConnectionProtocol
 "connection"(): $Connection
 "listener"(): $ICommonPacketListener
 "disconnect"(arg0: $Component$$Type): void
 "enqueueWork"<T>(arg0: $Supplier$$Type<(T)>): $CompletableFuture<(T)>
 "enqueueWork"(arg0: $Runnable$$Type): $CompletableFuture<(void)>
 "player"(): $Player
 "reply"(arg0: $CustomPacketPayload$$Type): void
 "flow"(): $PacketFlow
 "channelHandlerContext"(): $ChannelHandlerContext
 "finishCurrentTask"(arg0: $ConfigurationTask$Type$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPayloadContext$$Type = ($IPayloadContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPayloadContext_ = $IPayloadContext$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.EffectParticleModificationEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$ParticleOptions, $ParticleOptions$$Type} from "net.minecraft.core.particles.ParticleOptions"

export class $EffectParticleModificationEvent extends $LivingEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $MobEffectInstance$$Type)

public "setParticleOptions"(arg0: $ParticleOptions$$Type): void
public "getParticleOptions"(): $ParticleOptions
public "isVisible"(): boolean
public "getEffect"(): $MobEffectInstance
public "setVisible"(arg0: boolean): void
public "getOriginalParticleOptions"(): $ParticleOptions
set "particleOptions"(value: $ParticleOptions$$Type)
get "particleOptions"(): $ParticleOptions
get "visible"(): boolean
get "effect"(): $MobEffectInstance
set "visible"(value: boolean)
get "originalParticleOptions"(): $ParticleOptions
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EffectParticleModificationEvent$$Type = ($EffectParticleModificationEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EffectParticleModificationEvent_ = $EffectParticleModificationEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.server.ServerStartedEvent" {
import {$ServerLifecycleEvent, $ServerLifecycleEvent$$Type} from "net.neoforged.neoforge.event.server.ServerLifecycleEvent"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerStartedEvent extends $ServerLifecycleEvent {

constructor(arg0: $MinecraftServer$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerStartedEvent$$Type = ($ServerStartedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerStartedEvent_ = $ServerStartedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderHighlightEvent" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$LevelRenderer, $LevelRenderer$$Type} from "net.minecraft.client.renderer.LevelRenderer"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"

export class $RenderHighlightEvent extends $Event {


public "getCamera"(): $Camera
public "getTarget"(): $HitResult
public "getDeltaTracker"(): $DeltaTracker
public "getLevelRenderer"(): $LevelRenderer
public "getPoseStack"(): $PoseStack
public "getMultiBufferSource"(): $MultiBufferSource
get "camera"(): $Camera
get "target"(): $HitResult
get "deltaTracker"(): $DeltaTracker
get "levelRenderer"(): $LevelRenderer
get "poseStack"(): $PoseStack
get "multiBufferSource"(): $MultiBufferSource
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderHighlightEvent$$Type = ($RenderHighlightEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderHighlightEvent_ = $RenderHighlightEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent$Block" {
import {$BlockColors, $BlockColors$$Type} from "net.minecraft.client.color.block.BlockColors"
import {$Block, $Block$$Type} from "net.minecraft.world.level.block.Block"
import {$RegisterColorHandlersEvent, $RegisterColorHandlersEvent$$Type} from "net.neoforged.neoforge.client.event.RegisterColorHandlersEvent"
import {$BlockColor, $BlockColor$$Type} from "net.minecraft.client.color.block.BlockColor"

export class $RegisterColorHandlersEvent$Block extends $RegisterColorHandlersEvent {

constructor(arg0: $BlockColors$$Type)

public "register"(arg0: $BlockColor$$Type, ...arg1: ($Block$$Type)[]): void
public "getBlockColors"(): $BlockColors
get "blockColors"(): $BlockColors
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterColorHandlersEvent$Block$$Type = ($RegisterColorHandlersEvent$Block);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterColorHandlersEvent$Block_ = $RegisterColorHandlersEvent$Block$$Type;
}}
declare module "net.neoforged.neoforge.common.conditions.ICondition" {
import {$DynamicOps, $DynamicOps$$Type} from "com.mojang.serialization.DynamicOps"
import {$WithConditions, $WithConditions$$Type} from "net.neoforged.neoforge.common.conditions.WithConditions"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$ICondition$IContext, $ICondition$IContext$$Type} from "net.neoforged.neoforge.common.conditions.ICondition$IContext"
import {$List, $List$$Type} from "java.util.List"
import {$JsonElement, $JsonElement$$Type} from "com.google.gson.JsonElement"
import {$JsonObject, $JsonObject$$Type} from "com.google.gson.JsonObject"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"

export interface $ICondition {

 "test"(arg0: $ICondition$IContext$$Type): boolean
 "codec"(): $MapCodec<($ICondition)>
}

export namespace $ICondition {
const CODEC: $Codec<($ICondition)>
const LIST_CODEC: $Codec<($List<($ICondition)>)>
function writeConditions(arg0: $DynamicOps$$Type<($JsonElement$$Type)>, arg1: $JsonObject$$Type, arg2: $List$$Type<($ICondition$$Type)>): void
function writeConditions(arg0: $HolderLookup$Provider$$Type, arg1: $JsonObject$$Type, arg2: $List$$Type<($ICondition$$Type)>): void
function writeConditions(arg0: $HolderLookup$Provider$$Type, arg1: $JsonObject$$Type, ...arg2: ($ICondition$$Type)[]): void
function conditionsMatched<V>(arg0: $DynamicOps$$Type<(V)>, arg1: V): boolean
function getConditionally<V, T>(arg0: $Codec$$Type<(T)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
function getWithConditionalCodec<V, T>(arg0: $Codec$$Type<($Optional$$Type<(T)>)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
function getWithWithConditionsCodec<V, T>(arg0: $Codec$$Type<($Optional$$Type<($WithConditions$$Type<(T)>)>)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
const probejs$$marker: never
}
export class $ICondition$$Static implements $ICondition {
static readonly "CODEC": $Codec<($ICondition)>
static readonly "LIST_CODEC": $Codec<($List<($ICondition)>)>


 "test"(arg0: $ICondition$IContext$$Type): boolean
static "writeConditions"(arg0: $DynamicOps$$Type<($JsonElement$$Type)>, arg1: $JsonObject$$Type, arg2: $List$$Type<($ICondition$$Type)>): void
static "writeConditions"(arg0: $HolderLookup$Provider$$Type, arg1: $JsonObject$$Type, arg2: $List$$Type<($ICondition$$Type)>): void
static "writeConditions"(arg0: $HolderLookup$Provider$$Type, arg1: $JsonObject$$Type, ...arg2: ($ICondition$$Type)[]): void
static "conditionsMatched"<V>(arg0: $DynamicOps$$Type<(V)>, arg1: V): boolean
static "getConditionally"<V, T>(arg0: $Codec$$Type<(T)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
 "codec"(): $MapCodec<($ICondition)>
static "getWithConditionalCodec"<V, T>(arg0: $Codec$$Type<($Optional$$Type<(T)>)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
static "getWithWithConditionsCodec"<V, T>(arg0: $Codec$$Type<($Optional$$Type<($WithConditions$$Type<(T)>)>)>, arg1: $DynamicOps$$Type<(V)>, arg2: V): $Optional<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICondition$$Type = ($ICondition);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICondition_ = $ICondition$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.ArrowLooseEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $ArrowLooseEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $Level$$Type, arg3: integer, arg4: boolean)

public "getLevel"(): $Level
public "getCharge"(): integer
public "setCharge"(arg0: integer): void
public "hasAmmo"(): boolean
public "getBow"(): $ItemStack
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "level"(): $Level
get "charge"(): integer
set "charge"(value: integer)
get "bow"(): $ItemStack
set "canceled"(value: boolean)
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ArrowLooseEvent$$Type = ($ArrowLooseEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ArrowLooseEvent_ = $ArrowLooseEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.PistonEvent$PistonMoveType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $PistonEvent$PistonMoveType extends $Enum<($PistonEvent$PistonMoveType)> {
static readonly "RETRACT": $PistonEvent$PistonMoveType
readonly "isExtend": boolean
static readonly "EXTEND": $PistonEvent$PistonMoveType


public static "values"(): ($PistonEvent$PistonMoveType)[]
public static "valueOf"(arg0: string): $PistonEvent$PistonMoveType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PistonEvent$PistonMoveType$$Type = (("extend") | ("retract"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PistonEvent$PistonMoveType_ = $PistonEvent$PistonMoveType$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$LeftClickEmpty" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerInteractEvent$LeftClickEmpty extends $PlayerInteractEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$LeftClickEmpty$$Type = ($PlayerInteractEvent$LeftClickEmpty);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$LeftClickEmpty_ = $PlayerInteractEvent$LeftClickEmpty$$Type;
}}
declare module "net.neoforged.neoforge.common.world.StructureModifier$Phase" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $StructureModifier$Phase extends $Enum<($StructureModifier$Phase)> {
static readonly "ADD": $StructureModifier$Phase
static readonly "MODIFY": $StructureModifier$Phase
static readonly "AFTER_EVERYTHING": $StructureModifier$Phase
static readonly "REMOVE": $StructureModifier$Phase
static readonly "BEFORE_EVERYTHING": $StructureModifier$Phase


public static "values"(): ($StructureModifier$Phase)[]
public static "valueOf"(arg0: string): $StructureModifier$Phase
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StructureModifier$Phase$$Type = (("before_everything") | ("add") | ("remove") | ("modify") | ("after_everything"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StructureModifier$Phase_ = $StructureModifier$Phase$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerHeartTypeEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Gui$HeartType, $Gui$HeartType$$Type} from "net.minecraft.client.gui.Gui$HeartType"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerHeartTypeEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Gui$HeartType$$Type)

public "setType"(arg0: $Gui$HeartType$$Type): void
public "getType"(): $Gui$HeartType
public "getOriginalType"(): $Gui$HeartType
public "getEntity"(): $Entity
set "type"(value: $Gui$HeartType$$Type)
get "type"(): $Gui$HeartType
get "originalType"(): $Gui$HeartType
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerHeartTypeEvent$$Type = ($PlayerHeartTypeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerHeartTypeEvent_ = $PlayerHeartTypeEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IAttributeExtension" {
import {$AttributeModifier, $AttributeModifier$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$AttributeModifier$Operation, $AttributeModifier$Operation$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier$Operation"
import {$MutableComponent, $MutableComponent$$Type} from "net.minecraft.network.chat.MutableComponent"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$TextColor, $TextColor$$Type} from "net.minecraft.network.chat.TextColor"
import {$DecimalFormat, $DecimalFormat$$Type} from "java.text.DecimalFormat"

export interface $IAttributeExtension {

 "getBaseId"(): $ResourceLocation
 "getDebugInfo"(arg0: $AttributeModifier$$Type, arg1: $TooltipFlag$$Type): $Component
 "toValueComponent"(arg0: $AttributeModifier$Operation$$Type, arg1: double, arg2: $TooltipFlag$$Type): $MutableComponent
 "getMergedStyle"(arg0: boolean): $TextColor
 "toBaseComponent"(arg0: double, arg1: double, arg2: boolean, arg3: $TooltipFlag$$Type): $MutableComponent
 "toComponent"(arg0: $AttributeModifier$$Type, arg1: $TooltipFlag$$Type): $MutableComponent

(arg0: boolean): $TextColor$$Type
get "baseId"(): $ResourceLocation
}

export namespace $IAttributeExtension {
const FORMAT: $DecimalFormat
function isNullOrAddition(arg0: $AttributeModifier$Operation$$Type): boolean
const probejs$$marker: never
}
export class $IAttributeExtension$$Static implements $IAttributeExtension {
static readonly "FORMAT": $DecimalFormat


 "getBaseId"(): $ResourceLocation
 "getDebugInfo"(arg0: $AttributeModifier$$Type, arg1: $TooltipFlag$$Type): $Component
 "toValueComponent"(arg0: $AttributeModifier$Operation$$Type, arg1: double, arg2: $TooltipFlag$$Type): $MutableComponent
static "isNullOrAddition"(arg0: $AttributeModifier$Operation$$Type): boolean
 "getMergedStyle"(arg0: boolean): $TextColor
 "toBaseComponent"(arg0: double, arg1: double, arg2: boolean, arg3: $TooltipFlag$$Type): $MutableComponent
 "toComponent"(arg0: $AttributeModifier$$Type, arg1: $TooltipFlag$$Type): $MutableComponent
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IAttributeExtension$$Type = ((arg0: boolean) => $TextColor$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IAttributeExtension_ = $IAttributeExtension$$Type;
}}
declare module "net.neoforged.neoforgespi.locating.IModFile$Type" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $IModFile$Type extends $Enum<($IModFile$Type)> {
static readonly "MOD": $IModFile$Type
static readonly "GAMELIBRARY": $IModFile$Type
static readonly "LIBRARY": $IModFile$Type


public static "values"(): ($IModFile$Type)[]
public static "valueOf"(arg0: string): $IModFile$Type
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModFile$Type$$Type = (("mod") | ("library") | ("gamelibrary"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModFile$Type_ = $IModFile$Type$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.ServerTickEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$MinecraftServer, $MinecraftServer$$Type} from "net.minecraft.server.MinecraftServer"

export class $ServerTickEvent extends $Event {


public "getServer"(): $MinecraftServer
public "hasTime"(): boolean
get "server"(): $MinecraftServer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ServerTickEvent$$Type = ($ServerTickEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ServerTickEvent_ = $ServerTickEvent$$Type;
}}
declare module "net.neoforged.fml.common.asm.enumextension.ExtensionInfo" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$NetworkedEnum$NetworkCheck, $NetworkedEnum$NetworkCheck$$Type} from "net.neoforged.fml.common.asm.enumextension.NetworkedEnum$NetworkCheck"
import {$Record, $Record$$Type} from "java.lang.Record"
import {$IExtensibleEnum, $IExtensibleEnum$$Type} from "net.neoforged.fml.common.asm.enumextension.IExtensibleEnum"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $ExtensionInfo extends $Record {

constructor(extended: boolean, vanillaCount: integer, totalCount: integer, netCheck: $NetworkedEnum$NetworkCheck$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "vanillaCount"(): integer
public static "nonExtended"<T extends ($Enum<(T)>) & ($IExtensibleEnum)>(arg0: $Class$$Type<(T)>): $ExtensionInfo
public "netCheck"(): $NetworkedEnum$NetworkCheck
public "extended"(): boolean
public "totalCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExtensionInfo$$Type = ({"totalCount"?: integer, "vanillaCount"?: integer, "netCheck"?: $NetworkedEnum$NetworkCheck$$Type, "extended"?: boolean}) | ([totalCount?: integer, vanillaCount?: integer, netCheck?: $NetworkedEnum$NetworkCheck$$Type, extended?: boolean]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExtensionInfo_ = $ExtensionInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.level.SleepFinishedTimeEvent" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$ServerLevel, $ServerLevel$$Type} from "net.minecraft.server.level.ServerLevel"

export class $SleepFinishedTimeEvent extends $LevelEvent {

constructor(arg0: $ServerLevel$$Type, arg1: long, arg2: long)

public "getNewTime"(): long
public "setTimeAddition"(arg0: long): boolean
get "newTime"(): long
set "timeAddition"(value: long)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SleepFinishedTimeEvent$$Type = ($SleepFinishedTimeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SleepFinishedTimeEvent_ = $SleepFinishedTimeEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.level.LevelEvent$Save" {
import {$LevelEvent, $LevelEvent$$Type} from "net.neoforged.neoforge.event.level.LevelEvent"
import {$LevelAccessor, $LevelAccessor$$Type} from "net.minecraft.world.level.LevelAccessor"

export class $LevelEvent$Save extends $LevelEvent {

constructor(arg0: $LevelAccessor$$Type)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LevelEvent$Save$$Type = ($LevelEvent$Save);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LevelEvent$Save_ = $LevelEvent$Save$$Type;
}}
declare module "net.neoforged.neoforge.event.village.VillageSiegeEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Vec3, $Vec3$$Type} from "net.minecraft.world.phys.Vec3"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$VillageSiege, $VillageSiege$$Type} from "net.minecraft.world.entity.ai.village.VillageSiege"

export class $VillageSiegeEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $VillageSiege$$Type, arg1: $Level$$Type, arg2: $Player$$Type, arg3: $Vec3$$Type)

public "getLevel"(): $Level
public "getSiege"(): $VillageSiege
public "getPlayer"(): $Player
public "getAttemptedSpawnPos"(): $Vec3
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "level"(): $Level
get "siege"(): $VillageSiege
get "player"(): $Player
get "attemptedSpawnPos"(): $Vec3
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VillageSiegeEvent$$Type = ($VillageSiegeEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VillageSiegeEvent_ = $VillageSiegeEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent$DebugText" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Window, $Window$$Type} from "com.mojang.blaze3d.platform.Window"
import {$List, $List$$Type} from "java.util.List"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$CustomizeGuiOverlayEvent, $CustomizeGuiOverlayEvent$$Type} from "net.neoforged.neoforge.client.event.CustomizeGuiOverlayEvent"

export class $CustomizeGuiOverlayEvent$DebugText extends $CustomizeGuiOverlayEvent {

constructor(arg0: $Window$$Type, arg1: $GuiGraphics$$Type, arg2: $DeltaTracker$$Type, arg3: $List$$Type<(string)>, arg4: $List$$Type<(string)>)

public "getLeft"(): $List<(string)>
public "getRight"(): $List<(string)>
get "left"(): $List<(string)>
get "right"(): $List<(string)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CustomizeGuiOverlayEvent$DebugText$$Type = ($CustomizeGuiOverlayEvent$DebugText);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CustomizeGuiOverlayEvent$DebugText_ = $CustomizeGuiOverlayEvent$DebugText$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IBaseRailBlockExtension" {
import {$BlockGetter, $BlockGetter$$Type} from "net.minecraft.world.level.BlockGetter"
import {$AbstractMinecart, $AbstractMinecart$$Type} from "net.minecraft.world.entity.vehicle.AbstractMinecart"
import {$RailShape, $RailShape$$Type} from "net.minecraft.world.level.block.state.properties.RailShape"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IBaseRailBlockExtension {

 "getRailMaxSpeed"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): float
 "canMakeSlopes"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "getRailDirection"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): $RailShape
 "onMinecartPass"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): void
 "isValidRailShape"(arg0: $RailShape$$Type): boolean
 "isFlexibleRail"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
}

export namespace $IBaseRailBlockExtension {
const probejs$$marker: never
}
export class $IBaseRailBlockExtension$$Static implements $IBaseRailBlockExtension {


 "getRailMaxSpeed"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): float
 "canMakeSlopes"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
 "getRailDirection"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): $RailShape
 "onMinecartPass"(arg0: $BlockState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type, arg3: $AbstractMinecart$$Type): void
 "isValidRailShape"(arg0: $RailShape$$Type): boolean
 "isFlexibleRail"(arg0: $BlockState$$Type, arg1: $BlockGetter$$Type, arg2: $BlockPos$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBaseRailBlockExtension$$Type = ($IBaseRailBlockExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBaseRailBlockExtension_ = $IBaseRailBlockExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.util.TriState" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $TriState extends $Enum<($TriState)> {
static readonly "TRUE": $TriState
static readonly "FALSE": $TriState
static readonly "DEFAULT": $TriState


public "isTrue"(): boolean
public static "values"(): ($TriState)[]
public static "valueOf"(arg0: string): $TriState
public "isDefault"(): boolean
public "isFalse"(): boolean
get "true"(): boolean
get "default"(): boolean
get "false"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TriState$$Type = (("true") | ("default") | ("false"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TriState_ = $TriState$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$KeyPressed" {
import {$ScreenEvent$KeyInput, $ScreenEvent$KeyInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$KeyInput"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$KeyPressed extends $ScreenEvent$KeyInput {

constructor(arg0: $Screen$$Type, arg1: integer, arg2: integer, arg3: integer)

public "getModifiers"(): integer
public "getScanCode"(): integer
public "getKeyCode"(): integer
get "modifiers"(): integer
get "scanCode"(): integer
get "keyCode"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$KeyPressed$$Type = ($ScreenEvent$KeyPressed);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$KeyPressed_ = $ScreenEvent$KeyPressed$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AnvilRepairEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $AnvilRepairEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $ItemStack$$Type, arg2: $ItemStack$$Type, arg3: $ItemStack$$Type)

public "getOutput"(): $ItemStack
public "getLeft"(): $ItemStack
public "getRight"(): $ItemStack
public "setBreakChance"(arg0: float): void
public "getBreakChance"(): float
public "getEntity"(): $Entity
get "output"(): $ItemStack
get "left"(): $ItemStack
get "right"(): $ItemStack
set "breakChance"(value: float)
get "breakChance"(): float
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AnvilRepairEvent$$Type = ($AnvilRepairEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AnvilRepairEvent_ = $AnvilRepairEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSpawnEvent" {
import {$ServerLevelAccessor, $ServerLevelAccessor$$Type} from "net.minecraft.world.level.ServerLevelAccessor"
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $MobSpawnEvent extends $EntityEvent {


public "getY"(): double
public "getLevel"(): $ServerLevelAccessor
public "getEntity"(): $Entity
public "getZ"(): double
public "getX"(): double
get "y"(): double
get "level"(): $ServerLevelAccessor
get "entity"(): $Entity
get "z"(): double
get "x"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSpawnEvent$$Type = ($MobSpawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSpawnEvent_ = $MobSpawnEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IMobEffectExtension" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$EffectCure, $EffectCure$$Type} from "net.neoforged.neoforge.common.EffectCure"
import {$Set, $Set$$Type} from "java.util.Set"

export interface $IMobEffectExtension {

 "fillEffectCures"(arg0: $Set$$Type<($EffectCure$$Type)>, arg1: $MobEffectInstance$$Type): void
 "getSortOrder"(arg0: $MobEffectInstance$$Type): integer
}

export namespace $IMobEffectExtension {
const probejs$$marker: never
}
export class $IMobEffectExtension$$Static implements $IMobEffectExtension {


 "fillEffectCures"(arg0: $Set$$Type<($EffectCure$$Type)>, arg1: $MobEffectInstance$$Type): void
 "getSortOrder"(arg0: $MobEffectInstance$$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMobEffectExtension$$Type = ($IMobEffectExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMobEffectExtension_ = $IMobEffectExtension$$Type;
}}
declare module "net.neoforged.fml.config.IConfigSpec" {
import {$ModConfig, $ModConfig$$Type} from "net.neoforged.fml.config.ModConfig"
import {$IConfigSpec$ILoadedConfig, $IConfigSpec$ILoadedConfig$$Type} from "net.neoforged.fml.config.IConfigSpec$ILoadedConfig"
import {$UnmodifiableCommentedConfig, $UnmodifiableCommentedConfig$$Type} from "com.electronwill.nightconfig.core.UnmodifiableCommentedConfig"
import {$CommentedConfig, $CommentedConfig$$Type} from "com.electronwill.nightconfig.core.CommentedConfig"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export interface $IConfigSpec {

 "isEmpty"(): boolean
 "isCorrect"(arg0: $UnmodifiableCommentedConfig$$Type): boolean
 "correct"(arg0: $CommentedConfig$$Type): void
 "acceptConfig"(arg0: $IConfigSpec$ILoadedConfig$$Type): void
 "validateSpec"(arg0: $ModConfig$$Type): void
get "empty"(): boolean
}

export namespace $IConfigSpec {
const probejs$$marker: never
}
export class $IConfigSpec$$Static implements $IConfigSpec {


 "isEmpty"(): boolean
 "isCorrect"(arg0: $UnmodifiableCommentedConfig$$Type): boolean
 "correct"(arg0: $CommentedConfig$$Type): void
 "acceptConfig"(arg0: $IConfigSpec$ILoadedConfig$$Type): void
 "validateSpec"(arg0: $ModConfig$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IConfigSpec$$Type = ($IConfigSpec);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IConfigSpec_ = $IConfigSpec$$Type;
}}
declare module "net.neoforged.neoforge.common.world.StructureModifier" {
import {$Structure, $Structure$$Type} from "net.minecraft.world.level.levelgen.structure.Structure"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ModifiableStructureInfo$StructureInfo$Builder, $ModifiableStructureInfo$StructureInfo$Builder$$Type} from "net.neoforged.neoforge.common.world.ModifiableStructureInfo$StructureInfo$Builder"
import {$HolderSet, $HolderSet$$Type} from "net.minecraft.core.HolderSet"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$StructureModifier$Phase, $StructureModifier$Phase$$Type} from "net.neoforged.neoforge.common.world.StructureModifier$Phase"

export interface $StructureModifier {

 "modify"(arg0: $Holder$$Type<($Structure)>, arg1: $StructureModifier$Phase$$Type, arg2: $ModifiableStructureInfo$StructureInfo$Builder$$Type): void
 "codec"(): $MapCodec<($StructureModifier)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeStructureModifier
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeStructureModifierTag
}

export namespace $StructureModifier {
const DIRECT_CODEC: $Codec<($StructureModifier)>
const LIST_CODEC: $Codec<($HolderSet<($StructureModifier)>)>
const REFERENCE_CODEC: $Codec<($Holder<($StructureModifier)>)>
const probejs$$marker: never
}
export class $StructureModifier$$Static implements $StructureModifier {
static readonly "DIRECT_CODEC": $Codec<($StructureModifier)>
static readonly "LIST_CODEC": $Codec<($HolderSet<($StructureModifier)>)>
static readonly "REFERENCE_CODEC": $Codec<($Holder<($StructureModifier)>)>


 "modify"(arg0: $Holder$$Type<($Structure)>, arg1: $StructureModifier$Phase$$Type, arg2: $ModifiableStructureInfo$StructureInfo$Builder$$Type): void
 "codec"(): $MapCodec<($StructureModifier)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StructureModifier$$Type = (Special.NeoforgeStructureModifier);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StructureModifier_ = $StructureModifier$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.MobSplitEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$List, $List$$Type} from "java.util.List"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $MobSplitEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Mob$$Type, arg1: $List$$Type<($Mob$$Type)>)

public "getParent"(): $Mob
public "getChildren"(): $List<($Mob)>
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "parent"(): $Mob
get "children"(): $List<($Mob)>
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MobSplitEvent$$Type = ($MobSplitEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MobSplitEvent_ = $MobSplitEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ContainerScreenEvent$Render$Foreground" {
import {$ContainerScreenEvent$Render, $ContainerScreenEvent$Render$$Type} from "net.neoforged.neoforge.client.event.ContainerScreenEvent$Render"
import {$AbstractContainerScreen, $AbstractContainerScreen$$Type} from "net.minecraft.client.gui.screens.inventory.AbstractContainerScreen"
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"

export class $ContainerScreenEvent$Render$Foreground extends $ContainerScreenEvent$Render {

constructor(arg0: $AbstractContainerScreen$$Type<(any)>, arg1: $GuiGraphics$$Type, arg2: integer, arg3: integer)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ContainerScreenEvent$Render$Foreground$$Type = ($ContainerScreenEvent$Render$Foreground);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ContainerScreenEvent$Render$Foreground_ = $ContainerScreenEvent$Render$Foreground$$Type;
}}
declare module "net.neoforged.neoforge.client.ExtendedServerListData" {
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ExtendedServerListData extends $Record {

constructor(arg0: string, arg1: boolean, arg2: integer, arg3: string)
constructor(type: string, isCompatible: boolean, numberOfMods: integer, extraReason: string, truncated: boolean)

public "type"(): string
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "isCompatible"(): boolean
public "truncated"(): boolean
public "numberOfMods"(): integer
public "extraReason"(): string
get "compatible"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExtendedServerListData$$Type = ({"isCompatible"?: boolean, "extraReason"?: string, "numberOfMods"?: integer, "type"?: string, "truncated"?: boolean}) | ([isCompatible?: boolean, extraReason?: string, numberOfMods?: integer, type?: string, truncated?: boolean]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExtendedServerListData_ = $ExtendedServerListData$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerXpEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerXpEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerXpEvent$$Type = ($PlayerXpEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerXpEvent_ = $PlayerXpEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IMenuTypeExtension" {
import {$IContainerFactory, $IContainerFactory$$Type} from "net.neoforged.neoforge.network.IContainerFactory"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$MenuType, $MenuType$$Type} from "net.minecraft.world.inventory.MenuType"
import {$Inventory, $Inventory$$Type} from "net.minecraft.world.entity.player.Inventory"

export interface $IMenuTypeExtension<T> {

 "create"(arg0: integer, arg1: $Inventory$$Type, arg2: $RegistryFriendlyByteBuf$$Type): T

(arg0: integer, arg1: $Inventory, arg2: $RegistryFriendlyByteBuf): T
}

export namespace $IMenuTypeExtension {
function create<T extends $AbstractContainerMenu>(arg0: $IContainerFactory$$Type<(T)>): $MenuType<(T)>
const probejs$$marker: never
}
export class $IMenuTypeExtension$$Static<T> implements $IMenuTypeExtension {


static "create"<T extends $AbstractContainerMenu>(arg0: $IContainerFactory$$Type<(T)>): $MenuType<(T)>
 "create"(arg0: integer, arg1: $Inventory$$Type, arg2: $RegistryFriendlyByteBuf$$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMenuTypeExtension$$Type<T> = ((arg0: integer, arg1: $Inventory, arg2: $RegistryFriendlyByteBuf) => T);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMenuTypeExtension_<T> = $IMenuTypeExtension$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.client.event.ViewportEvent$ComputeCameraAngles" {
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$ViewportEvent, $ViewportEvent$$Type} from "net.neoforged.neoforge.client.event.ViewportEvent"

export class $ViewportEvent$ComputeCameraAngles extends $ViewportEvent {

constructor(arg0: $Camera$$Type, arg1: double, arg2: float, arg3: float, arg4: float)

public "setYaw"(arg0: float): void
public "getYaw"(): float
public "setPitch"(arg0: float): void
public "getRoll"(): float
public "setRoll"(arg0: float): void
public "getPitch"(): float
set "yaw"(value: float)
get "yaw"(): float
set "pitch"(value: float)
get "roll"(): float
set "roll"(value: float)
get "pitch"(): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ViewportEvent$ComputeCameraAngles$$Type = ($ViewportEvent$ComputeCameraAngles);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ViewportEvent$ComputeCameraAngles_ = $ViewportEvent$ComputeCameraAngles$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.ProjectileImpactEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Projectile, $Projectile$$Type} from "net.minecraft.world.entity.projectile.Projectile"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"

export class $ProjectileImpactEvent extends $EntityEvent implements $ICancellableEvent {

constructor(arg0: $Projectile$$Type, arg1: $HitResult$$Type)

public "getProjectile"(): $Projectile
public "getRayTraceResult"(): $HitResult
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "projectile"(): $Projectile
get "rayTraceResult"(): $HitResult
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ProjectileImpactEvent$$Type = ($ProjectileImpactEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ProjectileImpactEvent_ = $ProjectileImpactEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.callback.BakeCallback" {
import {$RegistryCallback, $RegistryCallback$$Type} from "net.neoforged.neoforge.registries.callback.RegistryCallback"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"

export interface $BakeCallback<T> extends $RegistryCallback<(T)> {

 "onBake"(arg0: $Registry$$Type<(T)>): void

(arg0: $Registry<(T)>): void
}

export namespace $BakeCallback {
const probejs$$marker: never
}
export class $BakeCallback$$Static<T> implements $BakeCallback {


 "onBake"(arg0: $Registry$$Type<(T)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BakeCallback$$Type<T> = ((arg0: $Registry<(T)>) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BakeCallback_<T> = $BakeCallback$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.registries.callback.AddCallback" {
import {$RegistryCallback, $RegistryCallback$$Type} from "net.neoforged.neoforge.registries.callback.RegistryCallback"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export interface $AddCallback<T> extends $RegistryCallback<(T)> {

 "onAdd"(arg0: $Registry$$Type<(T)>, arg1: integer, arg2: $ResourceKey$$Type<(T)>, arg3: T): void

(arg0: $Registry<(T)>, arg1: integer, arg2: $ResourceKey<(T)>, arg3: T): void
}

export namespace $AddCallback {
const probejs$$marker: never
}
export class $AddCallback$$Static<T> implements $AddCallback {


 "onAdd"(arg0: $Registry$$Type<(T)>, arg1: integer, arg2: $ResourceKey$$Type<(T)>, arg3: T): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AddCallback$$Type<T> = ((arg0: $Registry<(T)>, arg1: integer, arg2: $ResourceKey<(T)>, arg3: T) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AddCallback_<T> = $AddCallback$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.damagesource.DamageContainer$Reduction" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $DamageContainer$Reduction extends $Enum<($DamageContainer$Reduction)> {
static readonly "MOB_EFFECTS": $DamageContainer$Reduction
static readonly "ENCHANTMENTS": $DamageContainer$Reduction
static readonly "ARMOR": $DamageContainer$Reduction
static readonly "ABSORPTION": $DamageContainer$Reduction
static readonly "INVULNERABILITY": $DamageContainer$Reduction


public static "values"(): ($DamageContainer$Reduction)[]
public static "valueOf"(arg0: string): $DamageContainer$Reduction
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DamageContainer$Reduction$$Type = (("invulnerability") | ("armor") | ("enchantments") | ("mob_effects") | ("absorption"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DamageContainer$Reduction_ = $DamageContainer$Reduction$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$LeftClickBlock" {
import {$PlayerInteractEvent, $PlayerInteractEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Direction, $Direction$$Type} from "net.minecraft.core.Direction"
import {$PlayerInteractEvent$LeftClickBlock$Action, $PlayerInteractEvent$LeftClickBlock$Action$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerInteractEvent$LeftClickBlock$Action"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$TriState, $TriState$$Type} from "net.neoforged.neoforge.common.util.TriState"

export class $PlayerInteractEvent$LeftClickBlock extends $PlayerInteractEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $BlockPos$$Type, arg2: $Direction$$Type, arg3: $PlayerInteractEvent$LeftClickBlock$Action$$Type)

public "setCanceled"(arg0: boolean): void
public "getUseItem"(): $TriState
public "getUseBlock"(): $TriState
public "setUseBlock"(arg0: $TriState$$Type): void
public "setUseItem"(arg0: $TriState$$Type): void
public "getAction"(): $PlayerInteractEvent$LeftClickBlock$Action
public "isCanceled"(): boolean
public "getEntity"(): $Entity
set "canceled"(value: boolean)
get "useItem"(): $TriState
get "useBlock"(): $TriState
set "useBlock"(value: $TriState$$Type)
set "useItem"(value: $TriState$$Type)
get "action"(): $PlayerInteractEvent$LeftClickBlock$Action
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerInteractEvent$LeftClickBlock$$Type = ($PlayerInteractEvent$LeftClickBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerInteractEvent$LeftClickBlock_ = $PlayerInteractEvent$LeftClickBlock$$Type;
}}
declare module "net.neoforged.neoforge.registries.RegisterEvent$RegisterHelper" {
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export interface $RegisterEvent$RegisterHelper<T> {

 "register"(arg0: $ResourceKey$$Type<(T)>, arg1: T): void
 "register"(arg0: $ResourceLocation$$Type, arg1: T): void

(arg0: $ResourceLocation, arg1: T): void
}

export namespace $RegisterEvent$RegisterHelper {
const probejs$$marker: never
}
export class $RegisterEvent$RegisterHelper$$Static<T> implements $RegisterEvent$RegisterHelper {


 "register"(arg0: $ResourceKey$$Type<(T)>, arg1: T): void
 "register"(arg0: $ResourceLocation$$Type, arg1: T): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegisterEvent$RegisterHelper$$Type<T> = ((arg0: $ResourceLocation, arg1: T) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegisterEvent$RegisterHelper_<T> = $RegisterEvent$RegisterHelper$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.level.NoteBlockEvent$Play" {
import {$NoteBlockEvent, $NoteBlockEvent$$Type} from "net.neoforged.neoforge.event.level.NoteBlockEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$NoteBlockInstrument, $NoteBlockInstrument$$Type} from "net.minecraft.world.level.block.state.properties.NoteBlockInstrument"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $NoteBlockEvent$Play extends $NoteBlockEvent implements $ICancellableEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: integer, arg4: $NoteBlockInstrument$$Type)

public "setInstrument"(arg0: $NoteBlockInstrument$$Type): void
public "getInstrument"(): $NoteBlockInstrument
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "instrument"(value: $NoteBlockInstrument$$Type)
get "instrument"(): $NoteBlockInstrument
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NoteBlockEvent$Play$$Type = ($NoteBlockEvent$Play);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NoteBlockEvent$Play_ = $NoteBlockEvent$Play$$Type;
}}
declare module "net.neoforged.neoforge.client.event.EntityRenderersEvent$CreateSkullModels" {
import {$ImmutableMap$Builder, $ImmutableMap$Builder$$Type} from "com.google.common.collect.ImmutableMap$Builder"
import {$SkullModelBase, $SkullModelBase$$Type} from "net.minecraft.client.model.SkullModelBase"
import {$EntityRenderersEvent, $EntityRenderersEvent$$Type} from "net.neoforged.neoforge.client.event.EntityRenderersEvent"
import {$SkullBlock$Type, $SkullBlock$Type$$Type} from "net.minecraft.world.level.block.SkullBlock$Type"
import {$EntityModelSet, $EntityModelSet$$Type} from "net.minecraft.client.model.geom.EntityModelSet"

export class $EntityRenderersEvent$CreateSkullModels extends $EntityRenderersEvent {

constructor(arg0: $ImmutableMap$Builder$$Type<($SkullBlock$Type$$Type), ($SkullModelBase$$Type)>, arg1: $EntityModelSet$$Type)

public "getEntityModelSet"(): $EntityModelSet
public "registerSkullModel"(arg0: $SkullBlock$Type$$Type, arg1: $SkullModelBase$$Type): void
get "entityModelSet"(): $EntityModelSet
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityRenderersEvent$CreateSkullModels$$Type = ($EntityRenderersEvent$CreateSkullModels);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityRenderersEvent$CreateSkullModels_ = $EntityRenderersEvent$CreateSkullModels$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.EntityTickEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"

export class $EntityTickEvent extends $EntityEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EntityTickEvent$$Type = ($EntityTickEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EntityTickEvent_ = $EntityTickEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.settings.IKeyConflictContext" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IKeyConflictContext {

 "isActive"(): boolean
 "conflicts"(arg0: $IKeyConflictContext$$Type): boolean
get "active"(): boolean
}

export namespace $IKeyConflictContext {
const probejs$$marker: never
}
export class $IKeyConflictContext$$Static implements $IKeyConflictContext {


 "isActive"(): boolean
 "conflicts"(arg0: $IKeyConflictContext$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IKeyConflictContext$$Type = ($IKeyConflictContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IKeyConflictContext_ = $IKeyConflictContext$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$Clone" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$Clone extends $PlayerEvent {

constructor(arg0: $Player$$Type, arg1: $Player$$Type, arg2: boolean)

public "getEntity"(): $LivingEntity
public "getOriginal"(): $Player
public "isWasDeath"(): boolean
get "entity"(): $LivingEntity
get "original"(): $Player
get "wasDeath"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$Clone$$Type = ($PlayerEvent$Clone);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$Clone_ = $PlayerEvent$Clone$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDamageEvent$Post" {
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"
import {$LivingDamageEvent, $LivingDamageEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingDamageEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$DamageContainer$Reduction, $DamageContainer$Reduction$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer$Reduction"

export class $LivingDamageEvent$Post extends $LivingDamageEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageContainer$$Type)

public "getSource"(): $DamageSource
public "getBlockedDamage"(): float
public "getReduction"(arg0: $DamageContainer$Reduction$$Type): float
public "getNewDamage"(): float
public "getOriginalDamage"(): float
public "getShieldDamage"(): float
public "getPostAttackInvulnerabilityTicks"(): integer
get "source"(): $DamageSource
get "blockedDamage"(): float
get "newDamage"(): float
get "originalDamage"(): float
get "shieldDamage"(): float
get "postAttackInvulnerabilityTicks"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDamageEvent$Post$$Type = ($LivingDamageEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDamageEvent$Post_ = $LivingDamageEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.PlayerTickEvent" {
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerTickEvent extends $PlayerEvent {


public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerTickEvent$$Type = ($PlayerTickEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerTickEvent_ = $PlayerTickEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.BiomeModifier" {
import {$ModifiableBiomeInfo$BiomeInfo$Builder, $ModifiableBiomeInfo$BiomeInfo$Builder$$Type} from "net.neoforged.neoforge.common.world.ModifiableBiomeInfo$BiomeInfo$Builder"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$HolderSet, $HolderSet$$Type} from "net.minecraft.core.HolderSet"
import {$Biome, $Biome$$Type} from "net.minecraft.world.level.biome.Biome"
import {$BiomeModifier$Phase, $BiomeModifier$Phase$$Type} from "net.neoforged.neoforge.common.world.BiomeModifier$Phase"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export interface $BiomeModifier {

 "modify"(arg0: $Holder$$Type<($Biome)>, arg1: $BiomeModifier$Phase$$Type, arg2: $ModifiableBiomeInfo$BiomeInfo$Builder$$Type): void
 "codec"(): $MapCodec<($BiomeModifier)>
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Literal": Special.NeoforgeBiomeModifier
/**
 * This field is a type stub generated by ProbeJS and shall not be used in any sense.
 */
 "probejsInternal$$Tag": Special.NeoforgeBiomeModifierTag
}

export namespace $BiomeModifier {
const DIRECT_CODEC: $Codec<($BiomeModifier)>
const LIST_CODEC: $Codec<($HolderSet<($BiomeModifier)>)>
const REFERENCE_CODEC: $Codec<($Holder<($BiomeModifier)>)>
const probejs$$marker: never
}
export class $BiomeModifier$$Static implements $BiomeModifier {
static readonly "DIRECT_CODEC": $Codec<($BiomeModifier)>
static readonly "LIST_CODEC": $Codec<($HolderSet<($BiomeModifier)>)>
static readonly "REFERENCE_CODEC": $Codec<($Holder<($BiomeModifier)>)>


 "modify"(arg0: $Holder$$Type<($Biome)>, arg1: $BiomeModifier$Phase$$Type, arg2: $ModifiableBiomeInfo$BiomeInfo$Builder$$Type): void
 "codec"(): $MapCodec<($BiomeModifier)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BiomeModifier$$Type = (Special.NeoforgeBiomeModifier);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BiomeModifier_ = $BiomeModifier$$Type;
}}
declare module "net.neoforged.neoforge.common.IMinecartCollisionHandler" {
import {$AbstractMinecart, $AbstractMinecart$$Type} from "net.minecraft.world.entity.vehicle.AbstractMinecart"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$AABB, $AABB$$Type} from "net.minecraft.world.phys.AABB"

export interface $IMinecartCollisionHandler {

 "getBoundingBox"(arg0: $AbstractMinecart$$Type): $AABB
 "onEntityCollision"(arg0: $AbstractMinecart$$Type, arg1: $Entity$$Type): void
 "getMinecartCollisionBox"(arg0: $AbstractMinecart$$Type): $AABB
 "getCollisionBox"(arg0: $AbstractMinecart$$Type, arg1: $Entity$$Type): $AABB
}

export namespace $IMinecartCollisionHandler {
const probejs$$marker: never
}
export class $IMinecartCollisionHandler$$Static implements $IMinecartCollisionHandler {


 "getBoundingBox"(arg0: $AbstractMinecart$$Type): $AABB
 "onEntityCollision"(arg0: $AbstractMinecart$$Type, arg1: $Entity$$Type): void
 "getMinecartCollisionBox"(arg0: $AbstractMinecart$$Type): $AABB
 "getCollisionBox"(arg0: $AbstractMinecart$$Type, arg1: $Entity$$Type): $AABB
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IMinecartCollisionHandler$$Type = ($IMinecartCollisionHandler);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IMinecartCollisionHandler_ = $IMinecartCollisionHandler$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.AdvancementEvent$AdvancementProgressEvent$ProgressType" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $AdvancementEvent$AdvancementProgressEvent$ProgressType extends $Enum<($AdvancementEvent$AdvancementProgressEvent$ProgressType)> {
static readonly "GRANT": $AdvancementEvent$AdvancementProgressEvent$ProgressType
static readonly "REVOKE": $AdvancementEvent$AdvancementProgressEvent$ProgressType


public static "values"(): ($AdvancementEvent$AdvancementProgressEvent$ProgressType)[]
public static "valueOf"(arg0: string): $AdvancementEvent$AdvancementProgressEvent$ProgressType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AdvancementEvent$AdvancementProgressEvent$ProgressType$$Type = (("grant") | ("revoke"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AdvancementEvent$AdvancementProgressEvent$ProgressType_ = $AdvancementEvent$AdvancementProgressEvent$ProgressType$$Type;
}}
declare module "net.neoforged.neoforgespi.locating.IModFile" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$List, $List$$Type} from "java.util.List"
import {$IModFile$Type, $IModFile$Type$$Type} from "net.neoforged.neoforgespi.locating.IModFile$Type"
import {$ModFileInfoParser, $ModFileInfoParser$$Type} from "net.neoforged.neoforgespi.locating.ModFileInfoParser"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"
import {$IModFileInfo, $IModFileInfo$$Type} from "net.neoforged.neoforgespi.language.IModFileInfo"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$SecureJar, $SecureJar$$Type} from "cpw.mods.jarhandling.SecureJar"
import {$SecureJar$Status, $SecureJar$Status$$Type} from "cpw.mods.jarhandling.SecureJar$Status"
import {$ModFileScanData, $ModFileScanData$$Type} from "net.neoforged.neoforgespi.language.ModFileScanData"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$ModFileDiscoveryAttributes, $ModFileDiscoveryAttributes$$Type} from "net.neoforged.neoforgespi.locating.ModFileDiscoveryAttributes"

export interface $IModFile {

 "findResource"(...arg0: (string)[]): $Path
 "getType"(): $IModFile$Type
 "getFileName"(): string
 "getFilePath"(): $Path
 "getModInfos"(): $List<($IModInfo)>
 "getScanResult"(): $ModFileScanData
 "getModFileInfo"(): $IModFileInfo
 "getSubstitutionMap"(): $Supplier<($Map<(string), (any)>)>
 "setSecurityStatus"(arg0: $SecureJar$Status$$Type): void
 "getSecureJar"(): $SecureJar
 "getDiscoveryAttributes"(): $ModFileDiscoveryAttributes
get "type"(): $IModFile$Type
get "fileName"(): string
get "filePath"(): $Path
get "modInfos"(): $List<($IModInfo)>
get "scanResult"(): $ModFileScanData
get "modFileInfo"(): $IModFileInfo
get "substitutionMap"(): $Supplier<($Map<(string), (any)>)>
set "securityStatus"(value: $SecureJar$Status$$Type)
get "secureJar"(): $SecureJar
get "discoveryAttributes"(): $ModFileDiscoveryAttributes
}

export namespace $IModFile {
function create(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type): $IModFile
function create(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type, arg2: $IModFile$Type$$Type, arg3: $ModFileDiscoveryAttributes$$Type): $IModFile
function create(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type, arg2: $ModFileDiscoveryAttributes$$Type): $IModFile
const probejs$$marker: never
}
export class $IModFile$$Static implements $IModFile {


 "findResource"(...arg0: (string)[]): $Path
 "getType"(): $IModFile$Type
static "create"(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type): $IModFile
static "create"(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type, arg2: $IModFile$Type$$Type, arg3: $ModFileDiscoveryAttributes$$Type): $IModFile
static "create"(arg0: $SecureJar$$Type, arg1: $ModFileInfoParser$$Type, arg2: $ModFileDiscoveryAttributes$$Type): $IModFile
 "getFileName"(): string
 "getFilePath"(): $Path
 "getModInfos"(): $List<($IModInfo)>
 "getScanResult"(): $ModFileScanData
 "getModFileInfo"(): $IModFileInfo
 "getSubstitutionMap"(): $Supplier<($Map<(string), (any)>)>
 "setSecurityStatus"(arg0: $SecureJar$Status$$Type): void
 "getSecureJar"(): $SecureJar
 "getDiscoveryAttributes"(): $ModFileDiscoveryAttributes
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModFile$$Type = ($IModFile);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModFile_ = $IModFile$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLevelStageEvent" {
import {$RenderLevelStageEvent$Stage, $RenderLevelStageEvent$Stage$$Type} from "net.neoforged.neoforge.client.event.RenderLevelStageEvent$Stage"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Frustum, $Frustum$$Type} from "net.minecraft.client.renderer.culling.Frustum"
import {$LevelRenderer, $LevelRenderer$$Type} from "net.minecraft.client.renderer.LevelRenderer"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"
import {$Camera, $Camera$$Type} from "net.minecraft.client.Camera"
import {$Matrix4f, $Matrix4f$$Type} from "org.joml.Matrix4f"

export class $RenderLevelStageEvent extends $Event {

constructor(arg0: $RenderLevelStageEvent$Stage$$Type, arg1: $LevelRenderer$$Type, arg2: $PoseStack$$Type, arg3: $Matrix4f$$Type, arg4: $Matrix4f$$Type, arg5: integer, arg6: $DeltaTracker$$Type, arg7: $Camera$$Type, arg8: $Frustum$$Type)

public "getCamera"(): $Camera
public "getProjectionMatrix"(): $Matrix4f
public "getModelViewMatrix"(): $Matrix4f
public "getLevelRenderer"(): $LevelRenderer
public "getRenderTick"(): integer
public "getPoseStack"(): $PoseStack
public "getPartialTick"(): $DeltaTracker
public "getStage"(): $RenderLevelStageEvent$Stage
public "getFrustum"(): $Frustum
get "camera"(): $Camera
get "projectionMatrix"(): $Matrix4f
get "modelViewMatrix"(): $Matrix4f
get "levelRenderer"(): $LevelRenderer
get "renderTick"(): integer
get "poseStack"(): $PoseStack
get "partialTick"(): $DeltaTracker
get "stage"(): $RenderLevelStageEvent$Stage
get "frustum"(): $Frustum
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLevelStageEvent$$Type = ($RenderLevelStageEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLevelStageEvent_ = $RenderLevelStageEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ToastAddEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Toast, $Toast$$Type} from "net.minecraft.client.gui.components.toasts.Toast"

export class $ToastAddEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Toast$$Type)

public "getToast"(): $Toast
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "toast"(): $Toast
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ToastAddEvent$$Type = ($ToastAddEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ToastAddEvent_ = $ToastAddEvent$$Type;
}}
declare module "net.neoforged.neoforgespi.IIssueReporting" {
import {$ModLoadingIssue, $ModLoadingIssue$$Type} from "net.neoforged.fml.ModLoadingIssue"

export interface $IIssueReporting {

 "addIssue"(arg0: $ModLoadingIssue$$Type): void

(arg0: $ModLoadingIssue): void
}

export namespace $IIssueReporting {
const probejs$$marker: never
}
export class $IIssueReporting$$Static implements $IIssueReporting {


 "addIssue"(arg0: $ModLoadingIssue$$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IIssueReporting$$Type = ((arg0: $ModLoadingIssue) => void);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IIssueReporting_ = $IIssueReporting$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IClientCommonPacketListenerExtension" {
import {$PacketFlow, $PacketFlow$$Type} from "net.minecraft.network.protocol.PacketFlow"
import {$CrashReport, $CrashReport$$Type} from "net.minecraft.CrashReport"
import {$CustomPacketPayload$Type, $CustomPacketPayload$Type$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload$Type"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$DisconnectionDetails, $DisconnectionDetails$$Type} from "net.minecraft.network.DisconnectionDetails"
import {$ConnectionType, $ConnectionType$$Type} from "net.neoforged.neoforge.network.connection.ConnectionType"
import {$Exception, $Exception$$Type} from "java.lang.Exception"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$ConnectionProtocol, $ConnectionProtocol$$Type} from "net.minecraft.network.ConnectionProtocol"
import {$Packet, $Packet$$Type} from "net.minecraft.network.protocol.Packet"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$ICommonPacketListener, $ICommonPacketListener$$Type} from "net.neoforged.neoforge.common.extensions.ICommonPacketListener"
import {$ReentrantBlockableEventLoop, $ReentrantBlockableEventLoop$$Type} from "net.minecraft.util.thread.ReentrantBlockableEventLoop"
import {$Connection, $Connection$$Type} from "net.minecraft.network.Connection"
import {$CrashReportCategory, $CrashReportCategory$$Type} from "net.minecraft.CrashReportCategory"

export interface $IClientCommonPacketListenerExtension extends $ICommonPacketListener {

 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "getConnection"(): $Connection
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
get "mainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
get "connection"(): $Connection
get "connectionType"(): $ConnectionType
get "acceptingMessages"(): boolean
}

export namespace $IClientCommonPacketListenerExtension {
const probejs$$marker: never
}
export class $IClientCommonPacketListenerExtension$$Static implements $IClientCommonPacketListenerExtension {


 "disconnect"(arg0: $Component$$Type): void
 "send"(arg0: $CustomPacketPayload$$Type): void
 "getMainThreadEventLoop"(): $ReentrantBlockableEventLoop<(any)>
 "getConnection"(): $Connection
 "send"(arg0: $Packet$$Type<(any)>): void
 "getConnectionType"(): $ConnectionType
 "hasChannel"(arg0: $ResourceLocation$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$$Type): boolean
 "hasChannel"(arg0: $CustomPacketPayload$Type$$Type<(any)>): boolean
 "protocol"(): $ConnectionProtocol
 "onDisconnect"(arg0: $DisconnectionDetails$$Type): void
 "onPacketError"(arg0: $Packet$$Type<(any)>, arg1: $Exception$$Type): void
 "fillCrashReport"(arg0: $CrashReport$$Type): void
 "createDisconnectionInfo"(arg0: $Component$$Type, arg1: $Throwable$$Type): $DisconnectionDetails
 "shouldHandleMessage"(arg0: $Packet$$Type<(any)>): boolean
 "isAcceptingMessages"(): boolean
 "fillListenerSpecificCrashDetails"(arg0: $CrashReport$$Type, arg1: $CrashReportCategory$$Type): void
 "flow"(): $PacketFlow
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IClientCommonPacketListenerExtension$$Type = ($IClientCommonPacketListenerExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IClientCommonPacketListenerExtension_ = $IClientCommonPacketListenerExtension$$Type;
}}
declare module "net.neoforged.neoforge.common.world.chunk.TicketHelper" {
import {$Map, $Map$$Type} from "java.util.Map"
import {$UUID, $UUID$$Type} from "java.util.UUID"
import {$TicketSet, $TicketSet$$Type} from "net.neoforged.neoforge.common.world.chunk.TicketSet"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"

export class $TicketHelper {


public "removeTicket"(arg0: $BlockPos$$Type, arg1: long, arg2: boolean): void
public "removeTicket"(arg0: $UUID$$Type, arg1: long, arg2: boolean): void
public "getEntityTickets"(): $Map<($UUID), ($TicketSet)>
public "removeAllTickets"(arg0: $UUID$$Type): void
public "removeAllTickets"(arg0: $BlockPos$$Type): void
public "getBlockTickets"(): $Map<($BlockPos), ($TicketSet)>
get "entityTickets"(): $Map<($UUID), ($TicketSet)>
get "blockTickets"(): $Map<($BlockPos), ($TicketSet)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TicketHelper$$Type = ($TicketHelper);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TicketHelper_ = $TicketHelper$$Type;
}}
declare module "net.neoforged.neoforge.common.world.ModifiableBiomeInfo$BiomeInfo" {
import {$Biome$ClimateSettings, $Biome$ClimateSettings$$Type} from "net.minecraft.world.level.biome.Biome$ClimateSettings"
import {$MobSpawnSettings, $MobSpawnSettings$$Type} from "net.minecraft.world.level.biome.MobSpawnSettings"
import {$BiomeGenerationSettings, $BiomeGenerationSettings$$Type} from "net.minecraft.world.level.biome.BiomeGenerationSettings"
import {$BiomeSpecialEffects, $BiomeSpecialEffects$$Type} from "net.minecraft.world.level.biome.BiomeSpecialEffects"
import {$Record, $Record$$Type} from "java.lang.Record"

export class $ModifiableBiomeInfo$BiomeInfo extends $Record {

constructor(climateSettings: $Biome$ClimateSettings$$Type, effects: $BiomeSpecialEffects$$Type, generationSettings: $BiomeGenerationSettings$$Type, mobSpawnSettings: $MobSpawnSettings$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "effects"(): $BiomeSpecialEffects
public "climateSettings"(): $Biome$ClimateSettings
public "generationSettings"(): $BiomeGenerationSettings
public "mobSpawnSettings"(): $MobSpawnSettings
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModifiableBiomeInfo$BiomeInfo$$Type = ({"mobSpawnSettings"?: $MobSpawnSettings$$Type, "generationSettings"?: $BiomeGenerationSettings$$Type, "effects"?: $BiomeSpecialEffects$$Type, "climateSettings"?: $Biome$ClimateSettings$$Type}) | ([mobSpawnSettings?: $MobSpawnSettings$$Type, generationSettings?: $BiomeGenerationSettings$$Type, effects?: $BiomeSpecialEffects$$Type, climateSettings?: $Biome$ClimateSettings$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModifiableBiomeInfo$BiomeInfo_ = $ModifiableBiomeInfo$BiomeInfo$$Type;
}}
declare module "net.neoforged.neoforge.event.tick.PlayerTickEvent$Pre" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$PlayerTickEvent, $PlayerTickEvent$$Type} from "net.neoforged.neoforge.event.tick.PlayerTickEvent"

export class $PlayerTickEvent$Pre extends $PlayerTickEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerTickEvent$Pre$$Type = ($PlayerTickEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerTickEvent$Pre_ = $PlayerTickEvent$Pre$$Type;
}}
declare module "net.neoforged.fml.event.IModBusEvent" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export interface $IModBusEvent {

}

export namespace $IModBusEvent {
const probejs$$marker: never
}
export class $IModBusEvent$$Static implements $IModBusEvent {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IModBusEvent$$Type = ($IModBusEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IModBusEvent_ = $IModBusEvent$$Type;
}}
declare module "net.neoforged.neoforge.fluids.BaseFlowingFluid" {
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$Optional, $Optional$$Type} from "java.util.Optional"
import {$FlowingFluid, $FlowingFluid$$Type} from "net.minecraft.world.level.material.FlowingFluid"
import {$IntegerProperty, $IntegerProperty$$Type} from "net.minecraft.world.level.block.state.properties.IntegerProperty"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"
import {$LevelReader, $LevelReader$$Type} from "net.minecraft.world.level.LevelReader"
import {$Fluid, $Fluid$$Type} from "net.minecraft.world.level.material.Fluid"
import {$IdMapper, $IdMapper$$Type} from "net.minecraft.core.IdMapper"
import {$BooleanProperty, $BooleanProperty$$Type} from "net.minecraft.world.level.block.state.properties.BooleanProperty"
import {$Item, $Item$$Type} from "net.minecraft.world.item.Item"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"

export class $BaseFlowingFluid extends $FlowingFluid {
static readonly "FLUID_STATE_REGISTRY": $IdMapper<($FluidState)>
static readonly "FALLING": $BooleanProperty
static readonly "LEVEL": $IntegerProperty


public "getSource"(): $Fluid
public "canConvertToSource"(arg0: $FluidState$$Type, arg1: $Level$$Type, arg2: $BlockPos$$Type): boolean
public "getBucket"(): $Item
public "getFluidType"(): $FluidType
public "getFlowing"(): $Fluid
public "getTickDelay"(arg0: $LevelReader$$Type): integer
public "getPickupSound"(): $Optional<($SoundEvent)>
public "isSame"(arg0: $Fluid$$Type): boolean
public "asHolder"(): $Holder<(any)>
public static "wrap"(arg1: any): $ReplacementMatch
get "source"(): $Fluid
get "bucket"(): $Item
get "fluidType"(): $FluidType
get "flowing"(): $Fluid
get "pickupSound"(): $Optional<($SoundEvent)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BaseFlowingFluid$$Type = ($BaseFlowingFluid);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BaseFlowingFluid_ = $BaseFlowingFluid$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderLivingEvent$Pre" {
import {$MultiBufferSource, $MultiBufferSource$$Type} from "net.minecraft.client.renderer.MultiBufferSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PoseStack, $PoseStack$$Type} from "com.mojang.blaze3d.vertex.PoseStack"
import {$EntityModel, $EntityModel$$Type} from "net.minecraft.client.model.EntityModel"
import {$RenderLivingEvent, $RenderLivingEvent$$Type} from "net.neoforged.neoforge.client.event.RenderLivingEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"
import {$LivingEntityRenderer, $LivingEntityRenderer$$Type} from "net.minecraft.client.renderer.entity.LivingEntityRenderer"

export class $RenderLivingEvent$Pre<T extends $LivingEntity, M extends $EntityModel<(T)>> extends $RenderLivingEvent<(T), (M)> implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $LivingEntityRenderer$$Type<(T), (M)>, arg2: float, arg3: $PoseStack$$Type, arg4: $MultiBufferSource$$Type, arg5: integer)

public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderLivingEvent$Pre$$Type<T, M> = ($RenderLivingEvent$Pre<(T), (M)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderLivingEvent$Pre_<T, M> = $RenderLivingEvent$Pre$$Type<(T), (M)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerEvent$PlayerLoggedOutEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $PlayerEvent$PlayerLoggedOutEvent extends $PlayerEvent {

constructor(arg0: $Player$$Type)

public "getEntity"(): $LivingEntity
get "entity"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerEvent$PlayerLoggedOutEvent$$Type = ($PlayerEvent$PlayerLoggedOutEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerEvent$PlayerLoggedOutEvent_ = $PlayerEvent$PlayerLoggedOutEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.EnderManAngerEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$EnderMan, $EnderMan$$Type} from "net.minecraft.world.entity.monster.EnderMan"

export class $EnderManAngerEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $EnderMan$$Type, arg1: $Player$$Type)

public "getEntity"(): $Entity
public "getPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "entity"(): $Entity
get "player"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnderManAngerEvent$$Type = ($EnderManAngerEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnderManAngerEvent_ = $EnderManAngerEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.player.SweepAttackEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$PlayerEvent, $PlayerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $SweepAttackEvent extends $PlayerEvent implements $ICancellableEvent {

constructor(arg0: $Player$$Type, arg1: $Entity$$Type, arg2: boolean)

public "getTarget"(): $Entity
public "setCanceled"(arg0: boolean): void
public "isSweeping"(): boolean
public "setSweeping"(arg0: boolean): void
public "isVanillaSweep"(): boolean
public "isCanceled"(): boolean
public "getEntity"(): $Entity
get "target"(): $Entity
set "canceled"(value: boolean)
get "sweeping"(): boolean
set "sweeping"(value: boolean)
get "vanillaSweep"(): boolean
get "canceled"(): boolean
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SweepAttackEvent$$Type = ($SweepAttackEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SweepAttackEvent_ = $SweepAttackEvent$$Type;
}}
declare module "net.neoforged.neoforge.registries.IRegistryExtension" {
import {$RegistryCallback, $RegistryCallback$$Type} from "net.neoforged.neoforge.registries.callback.RegistryCallback"
import {$Map, $Map$$Type} from "java.util.Map"
import {$ResourceLocation, $ResourceLocation$$Type} from "net.minecraft.resources.ResourceLocation"
import {$DataMapType, $DataMapType$$Type} from "net.neoforged.neoforge.registries.datamaps.DataMapType"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"

export interface $IRegistryExtension<T> {

 "resolve"(arg0: $ResourceLocation$$Type): $ResourceLocation
 "resolve"(arg0: $ResourceKey$$Type<(T)>): $ResourceKey<(T)>
 "getId"(arg0: $ResourceKey$$Type<(T)>): integer
 "getId"(arg0: $ResourceLocation$$Type): integer
 "containsValue"(arg0: T): boolean
 "getData"<A>(arg0: $DataMapType$$Type<(T), (A)>, arg1: $ResourceKey$$Type<(T)>): A
 "addAlias"(arg0: $ResourceLocation$$Type, arg1: $ResourceLocation$$Type): void
 "getKeyOrNull"(arg0: T): $ResourceLocation
 "addCallback"<C extends $RegistryCallback<(T)>>(arg0: $Class$$Type<(C)>, arg1: C): void
 "addCallback"(arg0: $RegistryCallback$$Type<(T)>): void
 "getMaxId"(): integer
 "getDataMap"<A>(arg0: $DataMapType$$Type<(T), (A)>): $Map<($ResourceKey<(T)>), (A)>
 "doesSync"(): boolean
get "maxId"(): integer
}

export namespace $IRegistryExtension {
const probejs$$marker: never
}
export class $IRegistryExtension$$Static<T> implements $IRegistryExtension {


 "resolve"(arg0: $ResourceLocation$$Type): $ResourceLocation
 "resolve"(arg0: $ResourceKey$$Type<(T)>): $ResourceKey<(T)>
 "getId"(arg0: $ResourceKey$$Type<(T)>): integer
 "getId"(arg0: $ResourceLocation$$Type): integer
 "containsValue"(arg0: T): boolean
 "getData"<A>(arg0: $DataMapType$$Type<(T), (A)>, arg1: $ResourceKey$$Type<(T)>): A
 "addAlias"(arg0: $ResourceLocation$$Type, arg1: $ResourceLocation$$Type): void
 "getKeyOrNull"(arg0: T): $ResourceLocation
 "addCallback"<C extends $RegistryCallback<(T)>>(arg0: $Class$$Type<(C)>, arg1: C): void
 "addCallback"(arg0: $RegistryCallback$$Type<(T)>): void
 "getMaxId"(): integer
 "getDataMap"<A>(arg0: $DataMapType$$Type<(T), (A)>): $Map<($ResourceKey<(T)>), (A)>
 "doesSync"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IRegistryExtension$$Type<T> = ($IRegistryExtension<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IRegistryExtension_<T> = $IRegistryExtension$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.entity.player.PlayerContainerEvent$Open" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AbstractContainerMenu, $AbstractContainerMenu$$Type} from "net.minecraft.world.inventory.AbstractContainerMenu"
import {$PlayerContainerEvent, $PlayerContainerEvent$$Type} from "net.neoforged.neoforge.event.entity.player.PlayerContainerEvent"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"

export class $PlayerContainerEvent$Open extends $PlayerContainerEvent {

constructor(arg0: $Player$$Type, arg1: $AbstractContainerMenu$$Type)

public "getEntity"(): $Entity
get "entity"(): $Entity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerContainerEvent$Open$$Type = ($PlayerContainerEvent$Open);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerContainerEvent$Open_ = $PlayerContainerEvent$Open$$Type;
}}
declare module "net.neoforged.neoforge.common.brewing.IBrewingRecipe" {
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"

export interface $IBrewingRecipe {

 "getOutput"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): $ItemStack
 "isInput"(arg0: $ItemStack$$Type): boolean
 "isIngredient"(arg0: $ItemStack$$Type): boolean
}

export namespace $IBrewingRecipe {
const probejs$$marker: never
}
export class $IBrewingRecipe$$Static implements $IBrewingRecipe {


 "getOutput"(arg0: $ItemStack$$Type, arg1: $ItemStack$$Type): $ItemStack
 "isInput"(arg0: $ItemStack$$Type): boolean
 "isIngredient"(arg0: $ItemStack$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IBrewingRecipe$$Type = ($IBrewingRecipe);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IBrewingRecipe_ = $IBrewingRecipe$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.handler.IPermissionHandlerFactory" {
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$IPermissionHandler, $IPermissionHandler$$Type} from "net.neoforged.neoforge.server.permission.handler.IPermissionHandler"
import {$PermissionNode, $PermissionNode$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionNode"

export interface $IPermissionHandlerFactory {

 "create"(arg0: $Collection$$Type<($PermissionNode$$Type<(any)>)>): $IPermissionHandler

(arg0: $Collection<($PermissionNode<(any)>)>): $IPermissionHandler$$Type
}

export namespace $IPermissionHandlerFactory {
const probejs$$marker: never
}
export class $IPermissionHandlerFactory$$Static implements $IPermissionHandlerFactory {


 "create"(arg0: $Collection$$Type<($PermissionNode$$Type<(any)>)>): $IPermissionHandler
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPermissionHandlerFactory$$Type = ((arg0: $Collection<($PermissionNode<(any)>)>) => $IPermissionHandler$$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPermissionHandlerFactory_ = $IPermissionHandlerFactory$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased$Post" {
import {$ScreenEvent$MouseButtonReleased, $ScreenEvent$MouseButtonReleased$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseButtonReleased$Post$Result, $ScreenEvent$MouseButtonReleased$Post$Result$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased$Post$Result"

export class $ScreenEvent$MouseButtonReleased$Post extends $ScreenEvent$MouseButtonReleased {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean)

public "setResult"(arg0: $ScreenEvent$MouseButtonReleased$Post$Result$$Type): void
public "getResult"(): $ScreenEvent$MouseButtonReleased$Post$Result
public "wasReleaseHandled"(): boolean
public "getMouseY"(): double
public "getMouseX"(): double
public "getReleaseResult"(): boolean
set "result"(value: $ScreenEvent$MouseButtonReleased$Post$Result$$Type)
get "result"(): $ScreenEvent$MouseButtonReleased$Post$Result
get "mouseY"(): double
get "mouseX"(): double
get "releaseResult"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonReleased$Post$$Type = ($ScreenEvent$MouseButtonReleased$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonReleased$Post_ = $ScreenEvent$MouseButtonReleased$Post$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.BabyEntitySpawnEvent" {
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$AgeableMob, $AgeableMob$$Type} from "net.minecraft.world.entity.AgeableMob"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Mob, $Mob$$Type} from "net.minecraft.world.entity.Mob"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $BabyEntitySpawnEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Mob$$Type, arg1: $Mob$$Type, arg2: $AgeableMob$$Type)

public "getChild"(): $AgeableMob
public "getParentA"(): $Mob
public "getParentB"(): $Mob
public "setChild"(arg0: $AgeableMob$$Type): void
public "getCausedByPlayer"(): $Player
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "child"(): $AgeableMob
get "parentA"(): $Mob
get "parentB"(): $Mob
set "child"(value: $AgeableMob$$Type)
get "causedByPlayer"(): $Player
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BabyEntitySpawnEvent$$Type = ($BabyEntitySpawnEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BabyEntitySpawnEvent_ = $BabyEntitySpawnEvent$$Type;
}}
declare module "net.neoforged.fml.ModLoadingIssue" {
import {$ModLoadingIssue$Severity, $ModLoadingIssue$Severity$$Type} from "net.neoforged.fml.ModLoadingIssue$Severity"
import {$IModFile, $IModFile$$Type} from "net.neoforged.neoforgespi.locating.IModFile"
import {$List, $List$$Type} from "java.util.List"
import {$Throwable, $Throwable$$Type} from "java.lang.Throwable"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$Record, $Record$$Type} from "java.lang.Record"
import {$IModInfo, $IModInfo$$Type} from "net.neoforged.neoforgespi.language.IModInfo"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $ModLoadingIssue extends $Record {

constructor(arg0: $ModLoadingIssue$Severity$$Type, arg1: string, arg2: $List$$Type<(any)>)
constructor(severity: $ModLoadingIssue$Severity$$Type, translationKey: string, translationArgs: $List$$Type<(any)>, cause: $Throwable$$Type, affectedPath: $Path$$Type, affectedModFile: $IModFile$$Type, affectedMod: $IModInfo$$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "cause"(): $Throwable
public static "error"(arg0: string, ...arg1: (any)[]): $ModLoadingIssue
public static "warning"(arg0: string, ...arg1: (any)[]): $ModLoadingIssue
public "severity"(): $ModLoadingIssue$Severity
public "withSeverity"(arg0: $ModLoadingIssue$Severity$$Type): $ModLoadingIssue
public "withAffectedModFile"(arg0: $IModFile$$Type): $ModLoadingIssue
public "withCause"(arg0: $Throwable$$Type): $ModLoadingIssue
public "withAffectedMod"(arg0: $IModInfo$$Type): $ModLoadingIssue
public "translationKey"(): string
public "affectedMod"(): $IModInfo
public "translationArgs"(): $List<(any)>
public "affectedPath"(): $Path
public "affectedModFile"(): $IModFile
public "withAffectedPath"(arg0: $Path$$Type): $ModLoadingIssue
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModLoadingIssue$$Type = ({"cause"?: $Throwable$$Type, "translationKey"?: string, "translationArgs"?: $List$$Type<(any)>, "severity"?: $ModLoadingIssue$Severity$$Type, "affectedModFile"?: $IModFile$$Type, "affectedPath"?: $Path$$Type, "affectedMod"?: $IModInfo$$Type}) | ([cause?: $Throwable$$Type, translationKey?: string, translationArgs?: $List$$Type<(any)>, severity?: $ModLoadingIssue$Severity$$Type, affectedModFile?: $IModFile$$Type, affectedPath?: $Path$$Type, affectedMod?: $IModInfo$$Type]);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModLoadingIssue_ = $ModLoadingIssue$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingEvent" {
import {$EntityEvent, $EntityEvent$$Type} from "net.neoforged.neoforge.event.entity.EntityEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingEvent extends $EntityEvent {

constructor(arg0: $LivingEntity$$Type)

public "getEntity"(): $LivingEntity
get "entity"(): $LivingEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingEvent$$Type = ($LivingEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingEvent_ = $LivingEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.GatherEffectScreenTooltipsEvent" {
import {$MobEffectInstance, $MobEffectInstance$$Type} from "net.minecraft.world.effect.MobEffectInstance"
import {$EffectRenderingInventoryScreen, $EffectRenderingInventoryScreen$$Type} from "net.minecraft.client.gui.screens.inventory.EffectRenderingInventoryScreen"
import {$List, $List$$Type} from "java.util.List"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export class $GatherEffectScreenTooltipsEvent extends $Event {

constructor(arg0: $EffectRenderingInventoryScreen$$Type<(any)>, arg1: $MobEffectInstance$$Type, arg2: $List$$Type<($Component$$Type)>)

public "getScreen"(): $EffectRenderingInventoryScreen<(any)>
public "getEffectInstance"(): $MobEffectInstance
public "getTooltip"(): $List<($Component)>
get "screen"(): $EffectRenderingInventoryScreen<(any)>
get "effectInstance"(): $MobEffectInstance
get "tooltip"(): $List<($Component)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GatherEffectScreenTooltipsEvent$$Type = ($GatherEffectScreenTooltipsEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GatherEffectScreenTooltipsEvent_ = $GatherEffectScreenTooltipsEvent$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingUseTotemEvent" {
import {$LivingEvent, $LivingEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingEvent"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$InteractionHand, $InteractionHand$$Type} from "net.minecraft.world.InteractionHand"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingUseTotemEvent extends $LivingEvent implements $ICancellableEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageSource$$Type, arg2: $ItemStack$$Type, arg3: $InteractionHand$$Type)

public "getSource"(): $DamageSource
public "getHandHolding"(): $InteractionHand
public "getTotem"(): $ItemStack
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "source"(): $DamageSource
get "handHolding"(): $InteractionHand
get "totem"(): $ItemStack
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingUseTotemEvent$$Type = ($LivingUseTotemEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingUseTotemEvent_ = $LivingUseTotemEvent$$Type;
}}
declare module "net.neoforged.fml.config.ModConfig" {
import {$ModConfig$Type, $ModConfig$Type$$Type} from "net.neoforged.fml.config.ModConfig$Type"
import {$IConfigSpec$ILoadedConfig, $IConfigSpec$ILoadedConfig$$Type} from "net.neoforged.fml.config.IConfigSpec$ILoadedConfig"
import {$Path, $Path$$Type} from "java.nio.file.Path"
import {$IConfigSpec, $IConfigSpec$$Type} from "net.neoforged.fml.config.IConfigSpec"

/**
 * This class is not allowed By KubeJS!
 * You should not load the class, or KubeJS will throw an error.
 * Loading the class using require() will not throw an error, but the class will be undefined.
 */
export class $ModConfig {


public "getType"(): $ModConfig$Type
public "getFileName"(): string
public "getFullPath"(): $Path
public "getModId"(): string
public "getSpec"(): $IConfigSpec
public "getLoadedConfig"(): $IConfigSpec$ILoadedConfig
get "type"(): $ModConfig$Type
get "fileName"(): string
get "fullPath"(): $Path
get "modId"(): string
get "spec"(): $IConfigSpec
get "loadedConfig"(): $IConfigSpec$ILoadedConfig
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModConfig$$Type = ($ModConfig);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModConfig_ = $ModConfig$$Type;
}}
declare module "net.neoforged.neoforge.client.event.SelectMusicEvent" {
import {$ICancellableEvent, $ICancellableEvent$$Type} from "net.neoforged.bus.api.ICancellableEvent"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$SoundInstance, $SoundInstance$$Type} from "net.minecraft.client.resources.sounds.SoundInstance"
import {$Music, $Music$$Type} from "net.minecraft.sounds.Music"

export class $SelectMusicEvent extends $Event implements $ICancellableEvent {

constructor(arg0: $Music$$Type, arg1: $SoundInstance$$Type)

public "getOriginalMusic"(): $Music
public "getPlayingMusic"(): $SoundInstance
public "overrideMusic"(arg0: $Music$$Type): void
public "getMusic"(): $Music
public "setMusic"(arg0: $Music$$Type): void
public "setCanceled"(arg0: boolean): void
public "isCanceled"(): boolean
get "originalMusic"(): $Music
get "playingMusic"(): $SoundInstance
get "music"(): $Music
set "music"(value: $Music$$Type)
set "canceled"(value: boolean)
get "canceled"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SelectMusicEvent$$Type = ($SelectMusicEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SelectMusicEvent_ = $SelectMusicEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.extensions.IDataComponentMapBuilderExtensions" {
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$DataComponentType, $DataComponentType$$Type} from "net.minecraft.core.component.DataComponentType"
import {$DataComponentMap$Builder, $DataComponentMap$Builder$$Type} from "net.minecraft.core.component.DataComponentMap$Builder"

export interface $IDataComponentMapBuilderExtensions {

 "set"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): $DataComponentMap$Builder
}

export namespace $IDataComponentMapBuilderExtensions {
const probejs$$marker: never
}
export class $IDataComponentMapBuilderExtensions$$Static implements $IDataComponentMapBuilderExtensions {


 "set"<T>(arg0: $Supplier$$Type<($DataComponentType$$Type<(T)>)>, arg1: T): $DataComponentMap$Builder
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IDataComponentMapBuilderExtensions$$Type = ($IDataComponentMapBuilderExtensions);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IDataComponentMapBuilderExtensions_ = $IDataComponentMapBuilderExtensions$$Type;
}}
declare module "net.neoforged.neoforge.common.util.Lazy" {
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"

export class $Lazy<T> implements $Supplier<(T)> {


public "invalidate"(): void
public "get"(): T
public static "of"<T>(arg0: $Supplier$$Type<(T)>): $Lazy<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Lazy$$Type<T> = ($Lazy<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Lazy_<T> = $Lazy$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.event.level.block.CropGrowEvent$Post" {
import {$CropGrowEvent, $CropGrowEvent$$Type} from "net.neoforged.neoforge.event.level.block.CropGrowEvent"
import {$Level, $Level$$Type} from "net.minecraft.world.level.Level"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export class $CropGrowEvent$Post extends $CropGrowEvent {

constructor(arg0: $Level$$Type, arg1: $BlockPos$$Type, arg2: $BlockState$$Type, arg3: $BlockState$$Type)

public "getState"(): $BlockState
public "getOriginalState"(): $BlockState
get "state"(): $BlockState
get "originalState"(): $BlockState
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CropGrowEvent$Post$$Type = ($CropGrowEvent$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CropGrowEvent$Post_ = $CropGrowEvent$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.settings.KeyModifier" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$Supplier, $Supplier$$Type} from "java.util.function.Supplier"
import {$List, $List$$Type} from "java.util.List"
import {$IKeyConflictContext, $IKeyConflictContext$$Type} from "net.neoforged.neoforge.client.settings.IKeyConflictContext"
import {$InputConstants$Key, $InputConstants$Key$$Type} from "com.mojang.blaze3d.platform.InputConstants$Key"
import {$Component, $Component$$Type} from "net.minecraft.network.chat.Component"

export class $KeyModifier extends $Enum<($KeyModifier)> {
static readonly "SHIFT": $KeyModifier
static readonly "MODIFIER_VALUES": ($KeyModifier)[]
static readonly "ALT": $KeyModifier
static readonly "NONE": $KeyModifier
static readonly "CONTROL": $KeyModifier


public static "values"(): ($KeyModifier)[]
public static "valueOf"(arg0: string): $KeyModifier
public "matches"(arg0: $InputConstants$Key$$Type): boolean
public "isActive"(arg0: $IKeyConflictContext$$Type): boolean
public "codes"(): ($InputConstants$Key)[]
public "getCombinedName"(arg0: $InputConstants$Key$$Type, arg1: $Supplier$$Type<($Component$$Type)>): $Component
public static "getKeyModifier"(arg0: $InputConstants$Key$$Type): $KeyModifier
public static "valueFromString"(arg0: string): $KeyModifier
public static "getActiveModifiers"(): $List<($KeyModifier)>
/**
 * 
 * @deprecated
 */
public static "getActiveModifier"(): $KeyModifier
public static "isKeyCodeModifier"(arg0: $InputConstants$Key$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $KeyModifier$$Type = (("control") | ("shift") | ("alt") | ("none"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $KeyModifier_ = $KeyModifier$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ContainerScreenEvent" {
import {$AbstractContainerScreen, $AbstractContainerScreen$$Type} from "net.minecraft.client.gui.screens.inventory.AbstractContainerScreen"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"

export class $ContainerScreenEvent extends $Event {


public "getContainerScreen"(): $AbstractContainerScreen<(any)>
get "containerScreen"(): $AbstractContainerScreen<(any)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ContainerScreenEvent$$Type = ($ContainerScreenEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ContainerScreenEvent_ = $ContainerScreenEvent$$Type;
}}
declare module "net.neoforged.neoforge.server.permission.events.PermissionGatherEvent$Nodes" {
import {$Iterable, $Iterable$$Type} from "java.lang.Iterable"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$PermissionNode, $PermissionNode$$Type} from "net.neoforged.neoforge.server.permission.nodes.PermissionNode"
import {$PermissionGatherEvent, $PermissionGatherEvent$$Type} from "net.neoforged.neoforge.server.permission.events.PermissionGatherEvent"

export class $PermissionGatherEvent$Nodes extends $PermissionGatherEvent {

constructor()

public "getNodes"(): $Collection<($PermissionNode<(any)>)>
public "addNodes"(arg0: $Iterable$$Type<($PermissionNode$$Type<(any)>)>): void
public "addNodes"(...arg0: ($PermissionNode$$Type<(any)>)[]): void
get "nodes"(): $Collection<($PermissionNode<(any)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PermissionGatherEvent$Nodes$$Type = ($PermissionGatherEvent$Nodes);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PermissionGatherEvent$Nodes_ = $PermissionGatherEvent$Nodes$$Type;
}}
declare module "net.neoforged.neoforge.client.event.TextureAtlasStitchedEvent" {
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$TextureAtlas, $TextureAtlas$$Type} from "net.minecraft.client.renderer.texture.TextureAtlas"
import {$IModBusEvent, $IModBusEvent$$Type} from "net.neoforged.fml.event.IModBusEvent"

export class $TextureAtlasStitchedEvent extends $Event implements $IModBusEvent {

constructor(arg0: $TextureAtlas$$Type)

public "getAtlas"(): $TextureAtlas
get "atlas"(): $TextureAtlas
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TextureAtlasStitchedEvent$$Type = ($TextureAtlasStitchedEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TextureAtlasStitchedEvent_ = $TextureAtlasStitchedEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseDragged" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseInput, $ScreenEvent$MouseInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseInput"

export class $ScreenEvent$MouseDragged extends $ScreenEvent$MouseInput {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer, arg4: double, arg5: double)

public "getMouseButton"(): integer
public "getMouseY"(): double
public "getMouseX"(): double
public "getDragX"(): double
public "getDragY"(): double
get "mouseButton"(): integer
get "mouseY"(): double
get "mouseX"(): double
get "dragX"(): double
get "dragY"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseDragged$$Type = ($ScreenEvent$MouseDragged);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseDragged_ = $ScreenEvent$MouseDragged$$Type;
}}
declare module "net.neoforged.neoforge.client.event.RenderGuiEvent" {
import {$GuiGraphics, $GuiGraphics$$Type} from "net.minecraft.client.gui.GuiGraphics"
import {$Event, $Event$$Type} from "net.neoforged.bus.api.Event"
import {$DeltaTracker, $DeltaTracker$$Type} from "net.minecraft.client.DeltaTracker"

export class $RenderGuiEvent extends $Event {


public "getGuiGraphics"(): $GuiGraphics
public "getPartialTick"(): $DeltaTracker
get "guiGraphics"(): $GuiGraphics
get "partialTick"(): $DeltaTracker
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RenderGuiEvent$$Type = ($RenderGuiEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RenderGuiEvent_ = $RenderGuiEvent$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ClientTickEvent$Pre" {
import {$ClientTickEvent, $ClientTickEvent$$Type} from "net.neoforged.neoforge.client.event.ClientTickEvent"

export class $ClientTickEvent$Pre extends $ClientTickEvent {

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ClientTickEvent$Pre$$Type = ($ClientTickEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ClientTickEvent$Pre_ = $ClientTickEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.common.PercentageAttribute" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$AttributeModifier$Operation, $AttributeModifier$Operation$$Type} from "net.minecraft.world.entity.ai.attributes.AttributeModifier$Operation"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$Attribute, $Attribute$$Type} from "net.minecraft.world.entity.ai.attributes.Attribute"
import {$MutableComponent, $MutableComponent$$Type} from "net.minecraft.network.chat.MutableComponent"
import {$RangedAttribute, $RangedAttribute$$Type} from "net.minecraft.world.entity.ai.attributes.RangedAttribute"
import {$TooltipFlag, $TooltipFlag$$Type} from "net.minecraft.world.item.TooltipFlag"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $PercentageAttribute extends $RangedAttribute {
static readonly "CODEC": $Codec<($Holder<($Attribute)>)>
static readonly "STREAM_CODEC": $StreamCodec<($RegistryFriendlyByteBuf), ($Holder<($Attribute)>)>

constructor(arg0: string, arg1: double, arg2: double, arg3: double, arg4: double)
constructor(arg0: string, arg1: double, arg2: double, arg3: double)

public "toValueComponent"(arg0: $AttributeModifier$Operation$$Type, arg1: double, arg2: $TooltipFlag$$Type): $MutableComponent
public static "isNullOrAddition"(arg0: $AttributeModifier$Operation$$Type): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PercentageAttribute$$Type = ($PercentageAttribute);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PercentageAttribute_ = $PercentageAttribute$$Type;
}}
declare module "net.neoforged.neoforge.registries.holdersets.OrHolderSet$Type" {
import {$StreamCodec, $StreamCodec$$Type} from "net.minecraft.network.codec.StreamCodec"
import {$Registry, $Registry$$Type} from "net.minecraft.core.Registry"
import {$Codec, $Codec$$Type} from "com.mojang.serialization.Codec"
import {$ICustomHolderSet, $ICustomHolderSet$$Type} from "net.neoforged.neoforge.registries.holdersets.ICustomHolderSet"
import {$RegistryFriendlyByteBuf, $RegistryFriendlyByteBuf$$Type} from "net.minecraft.network.RegistryFriendlyByteBuf"
import {$ResourceKey, $ResourceKey$$Type} from "net.minecraft.resources.ResourceKey"
import {$MapCodec, $MapCodec$$Type} from "com.mojang.serialization.MapCodec"
import {$HolderSetType, $HolderSetType$$Type} from "net.neoforged.neoforge.registries.holdersets.HolderSetType"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $OrHolderSet$Type implements $HolderSetType {

constructor()

public "makeCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>, arg1: $Codec$$Type<($Holder$$Type<(T)>)>, arg2: boolean): $MapCodec<($ICustomHolderSet<(T)>)>
public "makeStreamCodec"<T>(arg0: $ResourceKey$$Type<($Registry<(T)>)>): $StreamCodec<($RegistryFriendlyByteBuf), ($ICustomHolderSet<(T)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $OrHolderSet$Type$$Type = ($OrHolderSet$Type);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $OrHolderSet$Type_ = $OrHolderSet$Type$$Type;
}}
declare module "net.neoforged.neoforge.capabilities.ICapabilityInvalidationListener" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ICapabilityInvalidationListener {

 "onInvalidate"(): boolean

(): boolean
}

export namespace $ICapabilityInvalidationListener {
const probejs$$marker: never
}
export class $ICapabilityInvalidationListener$$Static implements $ICapabilityInvalidationListener {


 "onInvalidate"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICapabilityInvalidationListener$$Type = (() => boolean);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICapabilityInvalidationListener_ = $ICapabilityInvalidationListener$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$CharacterTyped$Post" {
import {$ScreenEvent$CharacterTyped, $ScreenEvent$CharacterTyped$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$CharacterTyped"
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"

export class $ScreenEvent$CharacterTyped$Post extends $ScreenEvent$CharacterTyped {

constructor(arg0: $Screen$$Type, arg1: character, arg2: integer)

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$CharacterTyped$Post$$Type = ($ScreenEvent$CharacterTyped$Post);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$CharacterTyped$Post_ = $ScreenEvent$CharacterTyped$Post$$Type;
}}
declare module "net.neoforged.neoforge.client.event.ScreenEvent$MouseButtonReleased" {
import {$Screen, $Screen$$Type} from "net.minecraft.client.gui.screens.Screen"
import {$ScreenEvent$MouseInput, $ScreenEvent$MouseInput$$Type} from "net.neoforged.neoforge.client.event.ScreenEvent$MouseInput"

export class $ScreenEvent$MouseButtonReleased extends $ScreenEvent$MouseInput {

constructor(arg0: $Screen$$Type, arg1: double, arg2: double, arg3: integer)

public "getMouseY"(): double
public "getMouseX"(): double
public "getButton"(): integer
get "mouseY"(): double
get "mouseX"(): double
get "button"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ScreenEvent$MouseButtonReleased$$Type = ($ScreenEvent$MouseButtonReleased);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ScreenEvent$MouseButtonReleased_ = $ScreenEvent$MouseButtonReleased$$Type;
}}
declare module "net.neoforged.neoforge.fluids.BaseFlowingFluid$Flowing" {
import {$ReplacementMatch, $ReplacementMatch$$Type} from "dev.latvian.mods.kubejs.recipe.match.ReplacementMatch"
import {$IdMapper, $IdMapper$$Type} from "net.minecraft.core.IdMapper"
import {$IntegerProperty, $IntegerProperty$$Type} from "net.minecraft.world.level.block.state.properties.IntegerProperty"
import {$BooleanProperty, $BooleanProperty$$Type} from "net.minecraft.world.level.block.state.properties.BooleanProperty"
import {$BaseFlowingFluid$Properties, $BaseFlowingFluid$Properties$$Type} from "net.neoforged.neoforge.fluids.BaseFlowingFluid$Properties"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$BaseFlowingFluid, $BaseFlowingFluid$$Type} from "net.neoforged.neoforge.fluids.BaseFlowingFluid"
import {$Holder, $Holder$$Type} from "net.minecraft.core.Holder"

export class $BaseFlowingFluid$Flowing extends $BaseFlowingFluid {
static readonly "FLUID_STATE_REGISTRY": $IdMapper<($FluidState)>
static readonly "FALLING": $BooleanProperty
static readonly "LEVEL": $IntegerProperty

constructor(arg0: $BaseFlowingFluid$Properties$$Type)

public "getAmount"(arg0: $FluidState$$Type): integer
public "isSource"(arg0: $FluidState$$Type): boolean
public "asHolder"(): $Holder<(any)>
public static "wrap"(arg1: any): $ReplacementMatch
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BaseFlowingFluid$Flowing$$Type = ($BaseFlowingFluid$Flowing);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BaseFlowingFluid$Flowing_ = $BaseFlowingFluid$Flowing$$Type;
}}
declare module "net.neoforged.bus.api.Event" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export class $Event {


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Event$$Type = ($Event);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Event_ = $Event$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.living.LivingDamageEvent$Pre" {
import {$DamageSource, $DamageSource$$Type} from "net.minecraft.world.damagesource.DamageSource"
import {$DamageContainer, $DamageContainer$$Type} from "net.neoforged.neoforge.common.damagesource.DamageContainer"
import {$LivingDamageEvent, $LivingDamageEvent$$Type} from "net.neoforged.neoforge.event.entity.living.LivingDamageEvent"
import {$LivingEntity, $LivingEntity$$Type} from "net.minecraft.world.entity.LivingEntity"

export class $LivingDamageEvent$Pre extends $LivingDamageEvent {

constructor(arg0: $LivingEntity$$Type, arg1: $DamageContainer$$Type)

public "getSource"(): $DamageSource
public "setNewDamage"(arg0: float): void
public "getNewDamage"(): float
public "getContainer"(): $DamageContainer
public "getOriginalDamage"(): float
get "source"(): $DamageSource
set "newDamage"(value: float)
get "newDamage"(): float
get "container"(): $DamageContainer
get "originalDamage"(): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LivingDamageEvent$Pre$$Type = ($LivingDamageEvent$Pre);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LivingDamageEvent$Pre_ = $LivingDamageEvent$Pre$$Type;
}}
declare module "net.neoforged.neoforge.event.entity.item.ItemExpireEvent" {
import {$ItemEvent, $ItemEvent$$Type} from "net.neoforged.neoforge.event.entity.item.ItemEvent"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"

export class $ItemExpireEvent extends $ItemEvent {

constructor(arg0: $ItemEntity$$Type)

public "getExtraLife"(): integer
public "addExtraLife"(arg0: integer): void
public "setExtraLife"(arg0: integer): void
get "extraLife"(): integer
set "extraLife"(value: integer)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ItemExpireEvent$$Type = ($ItemExpireEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ItemExpireEvent_ = $ItemExpireEvent$$Type;
}}
declare module "net.neoforged.neoforge.common.world.BiomeModifier$Phase" {
import {$Enum, $Enum$$Type} from "java.lang.Enum"

export class $BiomeModifier$Phase extends $Enum<($BiomeModifier$Phase)> {
static readonly "ADD": $BiomeModifier$Phase
static readonly "MODIFY": $BiomeModifier$Phase
static readonly "AFTER_EVERYTHING": $BiomeModifier$Phase
static readonly "REMOVE": $BiomeModifier$Phase
static readonly "BEFORE_EVERYTHING": $BiomeModifier$Phase


public static "values"(): ($BiomeModifier$Phase)[]
public static "valueOf"(arg0: string): $BiomeModifier$Phase
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BiomeModifier$Phase$$Type = (("before_everything") | ("add") | ("remove") | ("modify") | ("after_everything"));
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BiomeModifier$Phase_ = $BiomeModifier$Phase$$Type;
}}
declare module "net.neoforged.neoforge.server.command.EnumArgument" {
import {$CommandContext, $CommandContext$$Type} from "com.mojang.brigadier.context.CommandContext"
import {$ArgumentType, $ArgumentType$$Type} from "com.mojang.brigadier.arguments.ArgumentType"
import {$Suggestions, $Suggestions$$Type} from "com.mojang.brigadier.suggestion.Suggestions"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$Enum, $Enum$$Type} from "java.lang.Enum"
import {$CompletableFuture, $CompletableFuture$$Type} from "java.util.concurrent.CompletableFuture"
import {$StringReader, $StringReader$$Type} from "com.mojang.brigadier.StringReader"
import {$Class, $Class$$Type} from "java.lang.Class"
import {$SuggestionsBuilder, $SuggestionsBuilder$$Type} from "com.mojang.brigadier.suggestion.SuggestionsBuilder"

export class $EnumArgument<T extends $Enum<(T)>> implements $ArgumentType<(T)> {


public "getExamples"(): $Collection<(string)>
public "parse"(arg0: $StringReader$$Type): any
public static "enumArgument"<R extends $Enum<(R)>>(arg0: $Class$$Type<(R)>): $EnumArgument<(R)>
public "listSuggestions"<S>(arg0: $CommandContext$$Type<(S)>, arg1: $SuggestionsBuilder$$Type): $CompletableFuture<($Suggestions)>
public "parse"<S>(arg0: $StringReader$$Type, arg1: S): T
get "examples"(): $Collection<(string)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnumArgument$$Type<T> = ($EnumArgument<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnumArgument_<T> = $EnumArgument$$Type<(T)>;
}}
declare module "net.neoforged.neoforge.common.extensions.IEntityExtension" {
import {$BiPredicate, $BiPredicate$$Type} from "java.util.function.BiPredicate"
import {$CompoundTag, $CompoundTag$$Type} from "net.minecraft.nbt.CompoundTag"
import {$Collection, $Collection$$Type} from "java.util.Collection"
import {$ItemStack, $ItemStack$$Type} from "net.minecraft.world.item.ItemStack"
import {$ItemEntity, $ItemEntity$$Type} from "net.minecraft.world.entity.item.ItemEntity"
import {$HitResult, $HitResult$$Type} from "net.minecraft.world.phys.HitResult"
import {$SoundEvent, $SoundEvent$$Type} from "net.minecraft.sounds.SoundEvent"
import {$CustomPacketPayload, $CustomPacketPayload$$Type} from "net.minecraft.network.protocol.common.custom.CustomPacketPayload"
import {$INBTSerializable, $INBTSerializable$$Type} from "net.neoforged.neoforge.common.util.INBTSerializable"
import {$HolderLookup$Provider, $HolderLookup$Provider$$Type} from "net.minecraft.core.HolderLookup$Provider"
import {$Consumer, $Consumer$$Type} from "java.util.function.Consumer"
import {$Player, $Player$$Type} from "net.minecraft.world.entity.player.Player"
import {$PartEntity, $PartEntity$$Type} from "net.neoforged.neoforge.entity.PartEntity"
import {$MobCategory, $MobCategory$$Type} from "net.minecraft.world.entity.MobCategory"
import {$Tag, $Tag$$Type} from "net.minecraft.nbt.Tag"
import {$BlockPos, $BlockPos$$Type} from "net.minecraft.core.BlockPos"
import {$Entity, $Entity$$Type} from "net.minecraft.world.entity.Entity"
import {$ServerPlayer, $ServerPlayer$$Type} from "net.minecraft.server.level.ServerPlayer"
import {$FluidState, $FluidState$$Type} from "net.minecraft.world.level.material.FluidState"
import {$FluidType, $FluidType$$Type} from "net.neoforged.neoforge.fluids.FluidType"
import {$SoundAction, $SoundAction$$Type} from "net.neoforged.neoforge.common.SoundAction"
import {$BlockState, $BlockState$$Type} from "net.minecraft.world.level.block.state.BlockState"

export interface $IEntityExtension extends $INBTSerializable<($CompoundTag)> {

 "revive"(): void
 "canTrample"(arg0: $BlockState$$Type, arg1: $BlockPos$$Type, arg2: float): boolean
 "canHydrateInFluidType"(arg0: $FluidType$$Type): boolean
 "getSoundFromFluidType"(arg0: $FluidType$$Type, arg1: $SoundAction$$Type): $SoundEvent
 "copyAttachmentsFrom"(arg0: $Entity$$Type, arg1: boolean): void
 "canBeRiddenUnderFluidType"(arg0: $FluidType$$Type, arg1: $Entity$$Type): boolean
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
/**
 * 
 * @deprecated
 */
 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): $Tag
 "shouldRiderSit"(): boolean
 "canRiderInteract"(): boolean
 "getClassification"(arg0: boolean): $MobCategory
 "getFluidTypeHeight"(arg0: $FluidType$$Type): double
 "onRemovedFromLevel"(): void
 "canSwimInFluidType"(arg0: $FluidType$$Type): boolean
 "getEyeInFluidType"(): $FluidType
 "canFluidExtinguish"(arg0: $FluidType$$Type): boolean
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): void
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): void
 "isMultipartEntity"(): boolean
 "sendPairingData"(arg0: $ServerPlayer$$Type, arg1: $Consumer$$Type<($CustomPacketPayload)>): void
 "isPushedByFluid"(arg0: $FluidType$$Type): boolean
 "getMaxHeightFluidType"(): $FluidType
 "getFluidMotionScale"(arg0: $FluidType$$Type): double
 "getParts"(): ($PartEntity<(any)>)[]
 "onAddedToLevel"(): void
 "getPersistentData"(): $CompoundTag
 "isAddedToLevel"(): boolean
 "captureDrops"(): $Collection<($ItemEntity)>
 "captureDrops"(arg0: $Collection$$Type<($ItemEntity$$Type)>): $Collection<($ItemEntity)>
 "isInFluidType"(arg0: $FluidState$$Type): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>): boolean
 "isInFluidType"(arg0: $FluidType$$Type): boolean
 "isInFluidType"(): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>, arg1: boolean): boolean
 "canStartSwimming"(): boolean
 "isEyeInFluidType"(arg0: $FluidType$$Type): boolean
 "getPickedResult"(arg0: $HitResult$$Type): $ItemStack
 "getFluidFallDistanceModifier"(arg0: $FluidType$$Type): float
get "eyeInFluidType"(): $FluidType
get "multipartEntity"(): boolean
get "maxHeightFluidType"(): $FluidType
get "parts"(): ($PartEntity<(any)>)[]
get "persistentData"(): $CompoundTag
get "addedToLevel"(): boolean
get "inFluidType"(): boolean
}

export namespace $IEntityExtension {
const probejs$$marker: never
}
export class $IEntityExtension$$Static implements $IEntityExtension {


 "revive"(): void
 "canTrample"(arg0: $BlockState$$Type, arg1: $BlockPos$$Type, arg2: float): boolean
 "canHydrateInFluidType"(arg0: $FluidType$$Type): boolean
 "getSoundFromFluidType"(arg0: $FluidType$$Type, arg1: $SoundAction$$Type): $SoundEvent
 "copyAttachmentsFrom"(arg0: $Entity$$Type, arg1: boolean): void
 "canBeRiddenUnderFluidType"(arg0: $FluidType$$Type, arg1: $Entity$$Type): boolean
 "hasCustomOutlineRendering"(arg0: $Player$$Type): boolean
/**
 * 
 * @deprecated
 */
 "serializeNBT"(arg0: $HolderLookup$Provider$$Type): $Tag
 "shouldRiderSit"(): boolean
 "canRiderInteract"(): boolean
 "getClassification"(arg0: boolean): $MobCategory
 "getFluidTypeHeight"(arg0: $FluidType$$Type): double
 "onRemovedFromLevel"(): void
 "canSwimInFluidType"(arg0: $FluidType$$Type): boolean
 "getEyeInFluidType"(): $FluidType
 "canFluidExtinguish"(arg0: $FluidType$$Type): boolean
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $Tag$$Type): void
/**
 * 
 * @deprecated
 */
 "deserializeNBT"(arg0: $HolderLookup$Provider$$Type, arg1: $CompoundTag$$Type): void
 "isMultipartEntity"(): boolean
 "sendPairingData"(arg0: $ServerPlayer$$Type, arg1: $Consumer$$Type<($CustomPacketPayload)>): void
 "isPushedByFluid"(arg0: $FluidType$$Type): boolean
 "getMaxHeightFluidType"(): $FluidType
 "getFluidMotionScale"(arg0: $FluidType$$Type): double
 "getParts"(): ($PartEntity<(any)>)[]
 "onAddedToLevel"(): void
 "getPersistentData"(): $CompoundTag
 "isAddedToLevel"(): boolean
 "captureDrops"(): $Collection<($ItemEntity)>
 "captureDrops"(arg0: $Collection$$Type<($ItemEntity$$Type)>): $Collection<($ItemEntity)>
 "isInFluidType"(arg0: $FluidState$$Type): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>): boolean
 "isInFluidType"(arg0: $FluidType$$Type): boolean
 "isInFluidType"(): boolean
 "isInFluidType"(arg0: $BiPredicate$$Type<($FluidType), (double)>, arg1: boolean): boolean
 "canStartSwimming"(): boolean
 "isEyeInFluidType"(arg0: $FluidType$$Type): boolean
 "getPickedResult"(arg0: $HitResult$$Type): $ItemStack
 "getFluidFallDistanceModifier"(arg0: $FluidType$$Type): float
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IEntityExtension$$Type = ($IEntityExtension);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IEntityExtension_ = $IEntityExtension$$Type;
}}
