declare module "packages/codechicken/lib/gui/modular/lib/$ElementEvents" {
import {$GuiElement, $GuiElement$Type} from "packages/codechicken/lib/gui/modular/elements/$GuiElement"
import {$List, $List$Type} from "packages/java/util/$List"

export interface $ElementEvents {

 "getChildren"(): $List<($GuiElement<(any)>)>
 "keyReleased"(arg0: integer, arg1: integer, arg2: integer): boolean
 "keyReleased"(arg0: integer, arg1: integer, arg2: integer, arg3: boolean): boolean
 "charTyped"(arg0: character, arg1: integer): boolean
 "charTyped"(arg0: character, arg1: integer, arg2: boolean): boolean
 "mouseClicked"(arg0: double, arg1: double, arg2: integer, arg3: boolean): boolean
 "mouseClicked"(arg0: double, arg1: double, arg2: integer): boolean
 "mouseReleased"(arg0: double, arg1: double, arg2: integer): boolean
 "mouseReleased"(arg0: double, arg1: double, arg2: integer, arg3: boolean): boolean
 "keyPressed"(arg0: integer, arg1: integer, arg2: integer, arg3: boolean): boolean
 "keyPressed"(arg0: integer, arg1: integer, arg2: integer): boolean
 "mouseScrolled"(arg0: double, arg1: double, arg2: double, arg3: boolean): boolean
 "mouseScrolled"(arg0: double, arg1: double, arg2: double): boolean
 "mouseMoved"(arg0: double, arg1: double): void
 "blockMouseEvents"(): boolean

(): $List<($GuiElement<(any)>)>
}

export namespace $ElementEvents {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ElementEvents$Type = ($ElementEvents);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ElementEvents_ = $ElementEvents$Type;
}}
declare module "packages/codechicken/lib/vec/$Translation" {
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Matrix4, $Matrix4$Type} from "packages/codechicken/lib/vec/$Matrix4"

export class $Translation extends $Transformation {
static readonly "CENTER": $Translation
 "vec": $Vector3
static readonly "operationIndex": integer

constructor(arg0: $Translation$Type)
constructor(arg0: double, arg1: double, arg2: double)
constructor(arg0: $Vec3i$Type)
constructor(arg0: $Vector3$Type)

public "toString"(): string
public "apply"(arg0: $Vector3$Type): void
public "apply"(arg0: $Matrix4$Type): void
public "merge"(arg0: $Transformation$Type): $Transformation
public "at"(arg0: $Vector3$Type): $Transformation
public "inverse"(): $Transformation
public "isRedundant"(): boolean
public "applyN"(arg0: $Vector3$Type): void
public static "registerOperation"(): integer
public static "operationCount"(): integer
get "redundant"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Translation$Type = ($Translation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Translation_ = $Translation$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$GeoParam" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"

export class $GeoParam extends $Enum<($GeoParam)> {
static readonly "LEFT": $GeoParam
static readonly "RIGHT": $GeoParam
static readonly "WIDTH": $GeoParam
static readonly "TOP": $GeoParam
static readonly "BOTTOM": $GeoParam
static readonly "HEIGHT": $GeoParam
readonly "axis": $Axis


public static "values"(): ($GeoParam)[]
public static "valueOf"(arg0: string): $GeoParam
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GeoParam$Type = (("top") | ("left") | ("bottom") | ("width") | ("right") | ("height")) | ($GeoParam);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GeoParam_ = $GeoParam$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/container/$SlotGroup" {
import {$ModularSlot, $ModularSlot$Type} from "packages/codechicken/lib/inventory/container/modular/$ModularSlot"
import {$ModularGuiContainerMenu, $ModularGuiContainerMenu$Type} from "packages/codechicken/lib/inventory/container/modular/$ModularGuiContainerMenu"
import {$Function, $Function$Type} from "packages/java/util/function/$Function"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Slot, $Slot$Type} from "packages/net/minecraft/world/inventory/$Slot"
import {$Container, $Container$Type} from "packages/net/minecraft/world/$Container"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$BiFunction, $BiFunction$Type} from "packages/java/util/function/$BiFunction"

export class $SlotGroup {
readonly "zone": integer
readonly "quickMoveTo": $List<(integer)>

constructor(arg0: $ModularGuiContainerMenu$Type, arg1: integer, ...arg2: (integer)[])

public "indexOf"(arg0: $Slot$Type): integer
public "size"(): integer
public "getSlot"(arg0: integer): $ModularSlot
public "slots"(): $List<($ModularSlot)>
public "addSlots"(arg0: integer, arg1: integer, arg2: $Function$Type<(integer), ($ModularSlot$Type)>): void
public "addSlot"(arg0: $ModularSlot$Type): $ModularSlot
public "addPlayerBar"(arg0: $Inventory$Type): void
public "addPlayerMain"(arg0: $Inventory$Type): void
public "addPlayerArmor"(arg0: $Inventory$Type): void
public "addPlayerOffhand"(arg0: $Inventory$Type): void
public "addAllSlots"(arg0: $Container$Type): void
public "addAllSlots"(arg0: $Container$Type, arg1: $BiFunction$Type<($Container$Type), (integer), ($ModularSlot$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SlotGroup$Type = ($SlotGroup);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SlotGroup_ = $SlotGroup$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Constraint" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export interface $Constraint {

 "get"(): double
 "axis"(): $Axis
 "markDirty"(): void
}

export namespace $Constraint {
function match(arg0: $GeoRef$Type): $ConstraintImpl$Relative
function between(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
function between(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
function between(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
function between(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
function literal(arg0: double): $ConstraintImpl$Literal
function relative(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
function relative(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
function dynamic(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
function midPoint(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
function midPoint(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
function midPoint(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Constraint$Type = ($Constraint);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Constraint_ = $Constraint$Type;
}}
declare module "packages/codechicken/lib/packet/$PacketCustom" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$IForgeRegistry, $IForgeRegistry$Type} from "packages/net/minecraftforge/registries/$IForgeRegistry"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$NetworkDirection, $NetworkDirection$Type} from "packages/net/minecraftforge/network/$NetworkDirection"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$CharBuffer, $CharBuffer$Type} from "packages/java/nio/$CharBuffer"
import {$ByteBuf, $ByteBuf$Type} from "packages/io/netty/buffer/$ByteBuf"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$Cuboid6, $Cuboid6$Type} from "packages/codechicken/lib/vec/$Cuboid6"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$DoubleBuffer, $DoubleBuffer$Type} from "packages/java/nio/$DoubleBuffer"
import {$ChunkPos, $ChunkPos$Type} from "packages/net/minecraft/world/level/$ChunkPos"
import {$ServerPlayer, $ServerPlayer$Type} from "packages/net/minecraft/server/level/$ServerPlayer"
import {$Packet, $Packet$Type} from "packages/net/minecraft/network/protocol/$Packet"
import {$ShortBuffer, $ShortBuffer$Type} from "packages/java/nio/$ShortBuffer"
import {$LongBuffer, $LongBuffer$Type} from "packages/java/nio/$LongBuffer"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$ByteBuffer, $ByteBuffer$Type} from "packages/java/nio/$ByteBuffer"
import {$MCDataByteBuf, $MCDataByteBuf$Type} from "packages/codechicken/lib/data/$MCDataByteBuf"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IntBuffer, $IntBuffer$Type} from "packages/java/nio/$IntBuffer"
import {$ResourceKey, $ResourceKey$Type} from "packages/net/minecraft/resources/$ResourceKey"

export class $PacketCustom extends $MCDataByteBuf {

constructor(arg0: $ByteBuf$Type)
constructor(arg0: $ResourceLocation$Type, arg1: integer)

public "append"(arg0: $ByteBuf$Type): $PacketCustom
public "getType"(): integer
public "getChannel"(): $ResourceLocation
public "writeFloat"(arg0: float): $PacketCustom
public "writeLong"(arg0: long): $PacketCustom
public "writeBoolean"(arg0: boolean): $PacketCustom
public "writeByte"(arg0: integer): $PacketCustom
public "writeDouble"(arg0: double): $PacketCustom
public "writeChars"(arg0: (character)[]): $PacketCustom
public "writeChars"(arg0: (character)[], arg1: integer, arg2: integer): $PacketCustom
public "writeItemStack"(arg0: $ItemStack$Type, arg1: boolean): $PacketCustom
public "writeRegistryId"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $PacketCustom
public "incoming"(): boolean
public static "sendToServer"(arg0: $Packet$Type<(any)>): void
public "sendToServer"(): void
public "writeShorts"(arg0: (short)[], arg1: integer, arg2: integer): $PacketCustom
public "writeLongs"(arg0: (long)[], arg1: integer, arg2: integer): $PacketCustom
public "writeLongs"(arg0: (long)[]): $PacketCustom
public "writeFloats"(arg0: (float)[]): $PacketCustom
public "writeFloats"(arg0: (float)[], arg1: integer, arg2: integer): $PacketCustom
public "writeDoubles"(arg0: (double)[], arg1: integer, arg2: integer): $PacketCustom
public "sendToDimension"(arg0: $ResourceKey$Type<($Level$Type)>): void
public static "sendToDimension"(arg0: $Packet$Type<(any)>, arg1: $ResourceKey$Type<($Level$Type)>): void
public static "sendToAllAround"(arg0: $Packet$Type<(any)>, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $ResourceKey$Type<($Level$Type)>): void
public "writeCharBuffer"(arg0: $CharBuffer$Type): $PacketCustom
public "writeVarLong"(arg0: long): $PacketCustom
public "writeShortBuffer"(arg0: $ShortBuffer$Type): $PacketCustom
public "writeByteBuffer"(arg0: $ByteBuffer$Type): $PacketCustom
public "writeLongBuffer"(arg0: $LongBuffer$Type): $PacketCustom
public "writeDoubleBuffer"(arg0: $DoubleBuffer$Type): $PacketCustom
public "writeVarLongs"(arg0: (long)[], arg1: integer, arg2: integer): $PacketCustom
public "writeIntBuffer"(arg0: $IntBuffer$Type): $PacketCustom
public "writeCuboid"(arg0: $Cuboid6$Type): $PacketCustom
public "writeCompoundNBT"(arg0: $CompoundTag$Type): $PacketCustom
public "writeVec3d"(arg0: $Vec3$Type): $PacketCustom
public "writeTextComponent"(arg0: $Component$Type): $PacketCustom
public "sendToChunk"(arg0: $Level$Type, arg1: $ChunkPos$Type): void
public static "sendToChunk"(arg0: $Packet$Type<(any)>, arg1: $Level$Type, arg2: $BlockPos$Type): void
public static "sendToChunk"(arg0: $Packet$Type<(any)>, arg1: $Level$Type, arg2: integer, arg3: integer): void
public "sendToChunk"(arg0: $BlockEntity$Type): void
public "sendToChunk"(arg0: $Level$Type, arg1: $BlockPos$Type): void
public static "sendToChunk"(arg0: $Packet$Type<(any)>, arg1: $Level$Type, arg2: $ChunkPos$Type): void
public "sendToChunk"(arg0: $Level$Type, arg1: integer, arg2: integer): void
public "sendToOps"(): void
public static "sendToOps"(arg0: $Packet$Type<(any)>): void
public "writeBooleans"(arg0: (boolean)[], arg1: integer, arg2: integer): $PacketCustom
public "writeBooleans"(arg0: (boolean)[]): $PacketCustom
public "writePos"(arg0: $BlockPos$Type): $PacketCustom
public "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $PacketCustom
public "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: T): $PacketCustom
public "sendPacketToAllAround"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: $ResourceKey$Type<($Level$Type)>): void
public "sendPacketToAllAround"(arg0: $BlockPos$Type, arg1: double, arg2: $ResourceKey$Type<($Level$Type)>): void
public "toPacket"(arg0: $NetworkDirection$Type): $Packet<(any)>
public "toPacket"(arg0: $NetworkDirection$Type, arg1: integer): $Packet<(any)>
public "sendToPlayer"(arg0: $ServerPlayer$Type): void
public static "sendToPlayer"(arg0: $Packet$Type<(any)>, arg1: $ServerPlayer$Type): void
public "sendToClients"(): void
public static "sendToClients"(arg0: $Packet$Type<(any)>): void
public "writeEnum"(arg0: $Enum$Type<(any)>): $PacketCustom
public "writeVarInt"(arg0: integer): $PacketCustom
get "type"(): integer
get "channel"(): $ResourceLocation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PacketCustom$Type = ($PacketCustom);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PacketCustom_ = $PacketCustom$Type;
}}
declare module "packages/codechicken/lib/vec/$Transformation" {
import {$ITransformation, $ITransformation$Type} from "packages/codechicken/lib/vec/$ITransformation"
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$TransformationList, $TransformationList$Type} from "packages/codechicken/lib/vec/$TransformationList"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"
import {$Matrix4, $Matrix4$Type} from "packages/codechicken/lib/vec/$Matrix4"

export class $Transformation extends $ITransformation<($Vector3), ($Transformation)> implements $IVertexOperation {
static readonly "operationIndex": integer

constructor()

public "load"(arg0: $CCRenderState$Type): boolean
public "apply"(arg0: $Matrix4$Type): void
public "at"(arg0: $Vector3$Type): $Transformation
public "with"(arg0: $Transformation$Type): $TransformationList
public "operationID"(): integer
public "applyN"(arg0: $Vector3$Type): void
public "operate"(arg0: $CCRenderState$Type): void
public static "registerOperation"(): integer
public static "operationCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Transformation$Type = ($Transformation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Transformation_ = $Transformation$Type;
}}
declare module "packages/codechicken/lib/render/pipeline/$IVertexSource" {
import {$Vertex5, $Vertex5$Type} from "packages/codechicken/lib/vec/$Vertex5"
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$AttributeKey, $AttributeKey$Type} from "packages/codechicken/lib/render/pipeline/attribute/$AttributeKey"

export interface $IVertexSource {

 "getAttribute"<T>(arg0: $AttributeKey$Type<(T)>): T
 "hasAttribute"(arg0: $AttributeKey$Type<(any)>): boolean
 "getVertices"(): ($Vertex5)[]
 "getVertexCount"(): integer
 "prepareVertex"(arg0: $CCRenderState$Type): void
}

export namespace $IVertexSource {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IVertexSource$Type = ($IVertexSource);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IVertexSource_ = $IVertexSource$Type;
}}
declare module "packages/codechicken/lib/render/pipeline/$CCRenderPipeline$PipelineBuilder" {
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$CCRenderPipeline, $CCRenderPipeline$Type} from "packages/codechicken/lib/render/pipeline/$CCRenderPipeline"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"

/**
 * 
 * @deprecated
 */
export class $CCRenderPipeline$PipelineBuilder {

constructor(arg0: $CCRenderPipeline$Type, arg1: $CCRenderState$Type)

public "add"(...arg0: ($IVertexOperation$Type)[]): $CCRenderPipeline$PipelineBuilder
public "add"(arg0: $IVertexOperation$Type): $CCRenderPipeline$PipelineBuilder
public "render"(): void
public "build"(): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CCRenderPipeline$PipelineBuilder$Type = ($CCRenderPipeline$PipelineBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CCRenderPipeline$PipelineBuilder_ = $CCRenderPipeline$PipelineBuilder$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$Literal extends $ConstraintImpl<($ConstraintImpl$Literal)> {

constructor(arg0: double)

public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$Literal$Type = ($ConstraintImpl$Literal);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$Literal_ = $ConstraintImpl$Literal$Type;
}}
declare module "packages/codechicken/lib/inventory/container/$ICCLContainerFactory" {
import {$MenuType$MenuSupplier, $MenuType$MenuSupplier$Type} from "packages/net/minecraft/world/inventory/$MenuType$MenuSupplier"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"

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

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

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

export namespace $ICCLContainerFactory {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICCLContainerFactory$Type<T> = ($ICCLContainerFactory<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICCLContainerFactory_<T> = $ICCLContainerFactory$Type<(T)>;
}}
declare module "packages/codechicken/lib/render/pipeline/$CCRenderPipeline" {
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$VertexAttribute, $VertexAttribute$Type} from "packages/codechicken/lib/render/pipeline/$VertexAttribute"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"
import {$CCRenderPipeline$PipelineBuilder, $CCRenderPipeline$PipelineBuilder$Type} from "packages/codechicken/lib/render/pipeline/$CCRenderPipeline$PipelineBuilder"

export class $CCRenderPipeline {
/**
 * 
 * @deprecated
 */
 "forceFormatAttributes": boolean

constructor(arg0: $CCRenderState$Type)

/**
 * 
 * @deprecated
 */
public "builder"(): $CCRenderPipeline$PipelineBuilder
public "reset"(): void
public "addAttribute"(arg0: $VertexAttribute$Type<(any)>): void
public "addDependency"(arg0: $VertexAttribute$Type<(any)>): void
public "rebuild"(): void
public "addRequirement"(arg0: integer): void
public "operate"(): void
public "setPipeline"(...arg0: ($IVertexOperation$Type)[]): void
set "pipeline"(value: ($IVertexOperation$Type)[])
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CCRenderPipeline$Type = ($CCRenderPipeline);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CCRenderPipeline_ = $CCRenderPipeline$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Borders" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export class $Borders {
 "top": double
 "left": double
 "bottom": double
 "right": double

constructor(arg0: double, arg1: double, arg2: double, arg3: double)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "top"(arg0: double): $Borders
public "top"(): double
public static "create"(arg0: double, arg1: double): $Borders
public static "create"(arg0: double): $Borders
public static "create"(arg0: double, arg1: double, arg2: double, arg3: double): $Borders
public "bottom"(arg0: double): $Borders
public "bottom"(): double
public "left"(arg0: double): $Borders
public "left"(): double
public "right"(arg0: double): $Borders
public "right"(): double
public "setBorders"(arg0: double, arg1: double): $Borders
public "setBorders"(arg0: double, arg1: double, arg2: double, arg3: double): $Borders
public "setBorders"(arg0: double): $Borders
public "setTopBottom"(arg0: double): $Borders
public "setLeftRight"(arg0: double): $Borders
set "borders"(value: double)
set "topBottom"(value: double)
set "leftRight"(value: double)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Borders$Type = ($Borders);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Borders_ = $Borders$Type;
}}
declare module "packages/codechicken/lib/inventory/container/modular/$ModularSlot" {
import {$BiConsumer, $BiConsumer$Type} from "packages/java/util/function/$BiConsumer"
import {$Function, $Function$Type} from "packages/java/util/function/$Function"
import {$BiPredicate, $BiPredicate$Type} from "packages/java/util/function/$BiPredicate"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Container, $Container$Type} from "packages/net/minecraft/world/$Container"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$IItemHandler, $IItemHandler$Type} from "packages/net/minecraftforge/items/$IItemHandler"
import {$SlotItemHandler, $SlotItemHandler$Type} from "packages/net/minecraftforge/items/$SlotItemHandler"

export class $ModularSlot extends $SlotItemHandler {
readonly "slot": integer
readonly "container": $Container
 "index": integer
 "x": integer
 "y": integer

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

public "output"(): $ModularSlot
public "setValidator"(arg0: $Predicate$Type<($ItemStack$Type)>): $ModularSlot
public "noCheck"(): $ModularSlot
public "set"(arg0: $ItemStack$Type): void
public "isActive"(): boolean
public "getMaxStackSize"(arg0: $ItemStack$Type): integer
public "mayPickup"(arg0: $Player$Type): boolean
public "mayPlace"(arg0: $ItemStack$Type): boolean
public "setEnabled"(arg0: boolean): $ModularSlot
public "setEnabled"(arg0: $Supplier$Type<(boolean)>): $ModularSlot
public "setStackLimit"(arg0: $Function$Type<($ItemStack$Type), (integer)>): $ModularSlot
public "onSet"(arg0: $BiConsumer$Type<($ItemStack$Type), ($ItemStack$Type)>): $ModularSlot
public "setCanRemove"(arg0: $BiPredicate$Type<($Player$Type), ($ItemStack$Type)>): $ModularSlot
set "validator"(value: $Predicate$Type<($ItemStack$Type)>)
get "active"(): boolean
set "enabled"(value: boolean)
set "enabled"(value: $Supplier$Type<(boolean)>)
set "stackLimit"(value: $Function$Type<($ItemStack$Type), (integer)>)
set "canRemove"(value: $BiPredicate$Type<($Player$Type), ($ItemStack$Type)>)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularSlot$Type = ($ModularSlot);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularSlot_ = $ModularSlot$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef" {
import {$GeoParam, $GeoParam$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoParam"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"

export class $GeoRef implements $Supplier<(double)> {
readonly "geometry": $GuiParent<(any)>
readonly "parameter": $GeoParam

constructor(arg0: $GuiParent$Type<(any)>, arg1: $GeoParam$Type)

public "toString"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GeoRef$Type = ($GeoRef);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GeoRef_ = $GeoRef$Type;
}}
declare module "packages/codechicken/lib/render/pipeline/$IVertexOperation" {
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"

export interface $IVertexOperation {

 "load"(arg0: $CCRenderState$Type): boolean
 "operationID"(): integer
 "operate"(arg0: $CCRenderState$Type): void
}

export namespace $IVertexOperation {
function registerOperation(): integer
function operationCount(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IVertexOperation$Type = ($IVertexOperation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IVertexOperation_ = $IVertexOperation$Type;
}}
declare module "packages/codechicken/lib/vec/uv/$UV" {
import {$UVTransformation, $UVTransformation$Type} from "packages/codechicken/lib/vec/uv/$UVTransformation"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $UV implements $Copyable<($UV)> {
 "u": double
 "v": double
 "tex": integer

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

public "add"(arg0: $UV$Type): $UV
public "equals"(arg0: any): boolean
public "toString"(): string
public "apply"(arg0: $UVTransformation$Type): $UV
public "set"(arg0: (float)[]): $UV
public "set"(arg0: double, arg1: double, arg2: integer): $UV
public "set"(arg0: double, arg1: double): $UV
public "set"(arg0: (double)[]): $UV
public "set"(arg0: $UV$Type): $UV
public "multiply"(arg0: double): $UV
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UV$Type = ($UV);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UV_ = $UV$Type;
}}
declare module "packages/codechicken/lib/vec/$TransformationList" {
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Matrix4, $Matrix4$Type} from "packages/codechicken/lib/vec/$Matrix4"

export class $TransformationList extends $Transformation {
static readonly "operationIndex": integer

constructor(arg0: $TransformationList$Type)
constructor(arg0: $List$Type<($Transformation$Type)>)
constructor(...arg0: ($Transformation$Type)[])

public "toString"(): string
public "compile"(): $Matrix4
public "apply"(arg0: $Matrix4$Type): void
public "apply"(arg0: $Vector3$Type): void
public "prepend"(arg0: $Transformation$Type): $TransformationList
public "with"(arg0: $Transformation$Type): $TransformationList
public "isRedundant"(): boolean
public "applyN"(arg0: $Vector3$Type): void
public "reverseCompile"(): $Matrix4
public static "registerOperation"(): integer
public static "operationCount"(): integer
get "redundant"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TransformationList$Type = ($TransformationList);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TransformationList_ = $TransformationList$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Constraint, $Constraint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Constraint"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl<T extends $ConstraintImpl<(any)>> implements $Constraint {

constructor()

public "get"(): double
public "axis"(): $Axis
public "markDirty"(): void
public "precise"(): T
public "setAxis"(arg0: $Axis$Type): T
public "isPrecise"(): boolean
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$Type<T> = ($ConstraintImpl<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl_<T> = $ConstraintImpl$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Position" {
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"

export interface $Position {

 "get"(arg0: $Axis$Type): double
 "offset"(arg0: double, arg1: double): $Position
 "x"(): double
 "y"(): double
}

export namespace $Position {
function create(arg0: $GuiParent$Type<(any)>): $Position
function create(arg0: double, arg1: double): $Position
function create(arg0: $Supplier$Type<(double)>, arg1: $Supplier$Type<(double)>): $Position
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Position$Type = ($Position);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Position_ = $Position$Type;
}}
declare module "packages/codechicken/lib/gui/modular/sprite/$Material" {
import {$Material as $Material$0, $Material$Type as $Material$0$Type} from "packages/net/minecraft/client/resources/model/$Material"
import {$VertexConsumer, $VertexConsumer$Type} from "packages/com/mojang/blaze3d/vertex/$VertexConsumer"
import {$Function, $Function$Type} from "packages/java/util/function/$Function"
import {$MultiBufferSource, $MultiBufferSource$Type} from "packages/net/minecraft/client/renderer/$MultiBufferSource"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$TextureAtlasSprite, $TextureAtlasSprite$Type} from "packages/net/minecraft/client/renderer/texture/$TextureAtlasSprite"
import {$RenderType, $RenderType$Type} from "packages/net/minecraft/client/renderer/$RenderType"

export class $Material {

constructor(arg0: $ResourceLocation$Type, arg1: $ResourceLocation$Type, arg2: $Function$Type<($ResourceLocation$Type), ($TextureAtlasSprite$Type)>)

public "buffer"(arg0: $MultiBufferSource$Type, arg1: $Function$Type<($ResourceLocation$Type), ($RenderType$Type)>): $VertexConsumer
public static "fromAtlas"(arg0: $ResourceLocation$Type, arg1: string): $Material
public "texture"(): $ResourceLocation
public "renderType"(arg0: $Function$Type<($ResourceLocation$Type), ($RenderType$Type)>): $RenderType
public "sprite"(): $TextureAtlasSprite
public "atlasLocation"(): $ResourceLocation
public "getVanillaMat"(): $Material$0
public static "fromSprite"(arg0: $TextureAtlasSprite$Type): $Material
public static "fromRawTexture"(arg0: $ResourceLocation$Type): $Material
get "vanillaMat"(): $Material$0
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Material$Type = ($Material);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Material_ = $Material$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$Relative extends $ConstraintImpl<($ConstraintImpl$Relative)> {

constructor(arg0: $GeoRef$Type, arg1: double)

public "getOffset"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "offset"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$Relative$Type = ($ConstraintImpl$Relative);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$Relative_ = $ConstraintImpl$Relative$Type;
}}
declare module "packages/codechicken/lib/vec/$Cuboid6" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$VoxelShape, $VoxelShape$Type} from "packages/net/minecraft/world/phys/shapes/$VoxelShape"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"
import {$AABB, $AABB$Type} from "packages/net/minecraft/world/phys/$AABB"

export class $Cuboid6 implements $Copyable<($Cuboid6)> {
static "full": $Cuboid6
 "min": $Vector3
 "max": $Vector3

constructor(arg0: $AABB$Type)
constructor(arg0: $CompoundTag$Type)
constructor(arg0: $Cuboid6$Type)
constructor(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double)
constructor()
constructor(arg0: $Vector3$Type, arg1: $Vector3$Type)
constructor(arg0: $Vec3i$Type, arg1: $Vec3i$Type)

public "add"(arg0: $BlockPos$Type): $Cuboid6
public "add"(arg0: double, arg1: double, arg2: double): $Cuboid6
public "add"(arg0: double): $Cuboid6
public "add"(arg0: $Vector3$Type): $Cuboid6
public "add"(arg0: $Vec3i$Type): $Cuboid6
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "apply"(arg0: $Transformation$Type): $Cuboid6
public "offset"(arg0: $Cuboid6$Type): $Cuboid6
public "contains"(arg0: double, arg1: double, arg2: double): boolean
public "contains"(arg0: $Vector3$Type): boolean
public "set"(arg0: $Vector3$Type, arg1: $Vector3$Type): $Cuboid6
public "set"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double): $Cuboid6
public "set"(arg0: $AABB$Type): $Cuboid6
public "set"(arg0: $Vec3i$Type, arg1: $Vec3i$Type): $Cuboid6
public "set"(arg0: $Cuboid6$Type): $Cuboid6
public "copy"(): $Cuboid6
public "expand"(arg0: double): $Cuboid6
public "expand"(arg0: $Vector3$Type): $Cuboid6
public "expand"(arg0: double, arg1: double, arg2: double): $Cuboid6
public "shape"(): $VoxelShape
public "subtract"(arg0: $Vector3$Type): $Cuboid6
public "subtract"(arg0: $Vec3i$Type): $Cuboid6
public "subtract"(arg0: $Vec3$Type): $Cuboid6
public "subtract"(arg0: $BlockPos$Type): $Cuboid6
public "subtract"(arg0: double): $Cuboid6
public "subtract"(arg0: double, arg1: double, arg2: double): $Cuboid6
public "getSide"(arg0: $Direction$Type): double
public "getSide"(arg0: integer): double
public "setSide"(arg0: integer, arg1: double): $Cuboid6
public "setSide"(arg0: $Direction$Type, arg1: double): $Cuboid6
public "volume"(): double
public "intersects"(arg0: $Cuboid6$Type): boolean
public "center"(): $Vector3
public "aabb"(): $AABB
public "writeToNBT"(arg0: $CompoundTag$Type): $CompoundTag
public "expandSide"(arg0: $Direction$Type, arg1: integer): $Cuboid6
public "equalsT"(arg0: $Cuboid6$Type): boolean
public "enclose"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double): $Cuboid6
public "enclose"(arg0: double, arg1: double, arg2: double): $Cuboid6
public "enclose"(arg0: $Vector3$Type): $Cuboid6
public "enclose"(arg0: $Cuboid6$Type): $Cuboid6
public "getSideSize"(arg0: $Direction$Type): double
public "shrinkSide"(arg0: $Direction$Type, arg1: integer): $Cuboid6
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Cuboid6$Type = ($Cuboid6);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Cuboid6_ = $Cuboid6$Type;
}}
declare module "packages/codechicken/lib/vec/$Quat" {
import {$Rotation, $Rotation$Type} from "packages/codechicken/lib/vec/$Rotation"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Quaterniond, $Quaterniond$Type} from "packages/org/joml/$Quaterniond"
import {$Quaternionf, $Quaternionf$Type} from "packages/org/joml/$Quaternionf"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $Quat implements $Copyable<($Quat)> {
 "x": double
 "y": double
 "z": double
 "s": double

constructor(arg0: double, arg1: double, arg2: double, arg3: double)
constructor(arg0: $Quaterniond$Type)
constructor(arg0: $Quaternionf$Type)
constructor(arg0: $Quat$Type)
constructor()

public "toString"(): string
public "set"(arg0: double, arg1: double, arg2: double, arg3: double): $Quat
public "set"(arg0: $Quat$Type): $Quat
public "copy"(): $Quat
public "normalize"(): $Quat
public "mag"(): double
public "rotate"(arg0: $Vector3$Type): void
public "rotation"(): $Rotation
public "setAroundAxis"(arg0: $Vector3$Type, arg1: double): $Quat
public "setAroundAxis"(arg0: double, arg1: double, arg2: double, arg3: double): $Quat
public "rightMultiply"(arg0: $Quat$Type): $Quat
public "toQuaternionF"(): $Quaternionf
public static "aroundAxis"(arg0: double, arg1: double, arg2: double, arg3: double): $Quat
public static "aroundAxis"(arg0: $Vector3$Type, arg1: double): $Quat
public "toQuaternionD"(): $Quaterniond
public "multiply"(arg0: $Quat$Type): $Quat
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Quat$Type = ($Quat);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Quat_ = $Quat$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Axis" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $Axis extends $Enum<($Axis)> {
static readonly "X": $Axis
static readonly "Y": $Axis


public static "values"(): ($Axis)[]
public static "valueOf"(arg0: string): $Axis
public "opposite"(): $Axis
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Axis$Type = (("x") | ("y")) | ($Axis);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Axis_ = $Axis$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Immutable" {
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Position, $Position$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position"
import {$Rectangle, $Rectangle$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Rectangle$Mutable, $Rectangle$Mutable$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Mutable"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"
import {$Rect2i, $Rect2i$Type} from "packages/net/minecraft/client/renderer/$Rect2i"

export class $Rectangle$Immutable extends $Record implements $Rectangle {

constructor(position: $Position$Type, xSize: double, ySize: double)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "position"(): $Position
public "pos"(): $Position
public "width"(): double
public "xSize"(): double
public "ySize"(): double
public "height"(): double
public "min"(arg0: $Axis$Type): double
public "max"(arg0: $Axis$Type): double
public "size"(arg0: $Axis$Type): double
public "x"(): double
public "contains"(arg0: double, arg1: double): boolean
public "combine"(...arg0: ($Rectangle$Type)[]): $Rectangle
public static "create"(arg0: $Position$Type, arg1: double, arg2: double): $Rectangle
public static "create"(arg0: $Position$Type, arg1: $Supplier$Type<(double)>, arg2: $Supplier$Type<(double)>): $Rectangle
public static "create"(arg0: double, arg1: double, arg2: double, arg3: double): $Rectangle
public static "create"(arg0: $GuiParent$Type<(any)>): $Rectangle
public "y"(): double
public "distance"(arg0: $Axis$Type, arg1: $Position$Type): double
public "offsetSize"(arg0: double, arg1: double): $Rectangle
public "setSize"(arg0: double, arg1: double): $Rectangle
public "mutable"(): $Rectangle$Mutable
public "intersects"(arg0: double, arg1: double, arg2: double, arg3: double): boolean
public "intersects"(arg0: $Rectangle$Type): boolean
public "intersect"(arg0: $Rectangle$Type): $Rectangle
public "setPos"(arg0: double, arg1: double): $Rectangle
public "offsetPos"(arg0: double, arg1: double): $Rectangle
public "yMax"(): double
public "xMax"(): double
public "toRect2i"(): $Rect2i
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Rectangle$Immutable$Type = ($Rectangle$Immutable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Rectangle$Immutable_ = $Rectangle$Immutable$Type;
}}
declare module "packages/codechicken/lib/vec/$ITransformation" {
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $ITransformation<Vector, Transformation extends $ITransformation<(Vector), (Transformation)>> implements $Copyable<(Transformation)> {

constructor()

public "apply"(arg0: Vector): void
public "merge"(arg0: Transformation): Transformation
public "at"(arg0: Vector): Transformation
public "with"(arg0: Transformation): Transformation
public "inverse"(): Transformation
public "$plus$plus"(arg0: Transformation): Transformation
public "isRedundant"(): boolean
public "copy"(): Transformation
get "redundant"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ITransformation$Type<Vector, Transformation> = ($ITransformation<(Vector), (Transformation)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ITransformation_<Vector, Transformation> = $ITransformation$Type<(Vector), (Transformation)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent" {
import {$Font, $Font$Type} from "packages/net/minecraft/client/gui/$Font"
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$GeoParam, $GeoParam$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoParam"
import {$GuiElement, $GuiElement$Type} from "packages/codechicken/lib/gui/modular/elements/$GuiElement"
import {$ModularGui, $ModularGui$Type} from "packages/codechicken/lib/gui/modular/$ModularGui"
import {$List, $List$Type} from "packages/java/util/$List"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"

export interface $GuiParent<T extends $GuiParent<(any)>> {

 "get"(arg0: $GeoParam$Type): $GeoRef
 "getValue"(arg0: $GeoParam$Type): double
 "mc"(): $Minecraft
 "getChildren"(): $List<($GuiElement<(any)>)>
 "removeChild"(arg0: $GuiElement$Type<(any)>): void
 "xSize"(): double
 "ySize"(): double
 "font"(): $Font
 "addChild"(arg0: $Consumer$Type<(T)>): T
 "addChild"(arg0: $GuiElement$Type<(any)>): void
 "getModularGui"(): $ModularGui
 "isDescendantOf"(arg0: $GuiElement$Type<(any)>): boolean
 "adoptChild"(arg0: $GuiElement$Type<(any)>): void
 "scaledScreenHeight"(): integer
 "scaledScreenWidth"(): integer
 "blockMouseOver"(arg0: $GuiElement$Type<(any)>, arg1: double, arg2: double): boolean
 "yMin"(): double
 "xMin"(): double
 "yMax"(): double
 "xMax"(): double
 "onScreenInit"(arg0: $Minecraft$Type, arg1: $Font$Type, arg2: integer, arg3: integer): void
}

export namespace $GuiParent {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiParent$Type<T> = ($GuiParent<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiParent_<T> = $GuiParent$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$BetweenDynamic extends $ConstraintImpl<($ConstraintImpl$BetweenDynamic)> {

constructor(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>)

public "getStart"(): double
public "clamp"(): $ConstraintImpl$BetweenDynamic
public "getPos"(): double
public "getEnd"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "start"(): double
get "pos"(): double
get "end"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$BetweenDynamic$Type = ($ConstraintImpl$BetweenDynamic);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$BetweenDynamic_ = $ConstraintImpl$BetweenDynamic$Type;
}}
declare module "packages/codechicken/lib/gui/modular/$ModularGui" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$MultiBufferSource$BufferSource, $MultiBufferSource$BufferSource$Type} from "packages/net/minecraft/client/renderer/$MultiBufferSource$BufferSource"
import {$GeoParam, $GeoParam$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoParam"
import {$Screen, $Screen$Type} from "packages/net/minecraft/client/gui/screens/$Screen"
import {$Slot, $Slot$Type} from "packages/net/minecraft/world/inventory/$Slot"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$TriConsumer, $TriConsumer$Type} from "packages/org/apache/logging/log4j/util/$TriConsumer"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$Runnable, $Runnable$Type} from "packages/java/lang/$Runnable"
import {$GuiRender, $GuiRender$Type} from "packages/codechicken/lib/gui/modular/lib/$GuiRender"
import {$Font, $Font$Type} from "packages/net/minecraft/client/gui/$Font"
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$GuiElement, $GuiElement$Type} from "packages/codechicken/lib/gui/modular/elements/$GuiElement"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$List, $List$Type} from "packages/java/util/$List"
import {$GuiProvider, $GuiProvider$Type} from "packages/codechicken/lib/gui/modular/lib/$GuiProvider"

export class $ModularGui implements $GuiParent<($ModularGui)> {

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

public "mc"(): $Minecraft
public "getRoot"(): $GuiElement<(any)>
public "setSlotHandler"(arg0: $Slot$Type, arg1: $GuiElement$Type<(any)>): void
public "getChildren"(): $List<($GuiElement<(any)>)>
public "onClose"(arg0: $Runnable$Type): void
public "getProvider"(): $GuiProvider
public "tick"(): void
public "removeChild"(arg0: $GuiElement$Type<(any)>): void
public "xSize"(): double
public "ySize"(): double
public "font"(): $Font
public "render"(arg0: $GuiRender$Type, arg1: float): void
public "doesFloatingItemDisableToolTips"(): boolean
public "renderScreenBackground"(arg0: boolean): void
public "addChild"(arg0: $Consumer$Type<($ModularGui$Type)>): $ModularGui
public "addChild"(arg0: $GuiElement$Type<(any)>): void
public "setCursor"(arg0: $ResourceLocation$Type): void
public "keyReleased"(arg0: integer, arg1: integer, arg2: integer): boolean
public "charTyped"(arg0: character, arg1: integer): boolean
public "mouseClicked"(arg0: double, arg1: double, arg2: integer): boolean
public "mouseReleased"(arg0: double, arg1: double, arg2: integer): boolean
public "keyPressed"(arg0: integer, arg1: integer, arg2: integer): boolean
public "mouseScrolled"(arg0: double, arg1: double, arg2: double): boolean
public "renderBackground"(): boolean
public "renderOverlay"(arg0: $GuiRender$Type, arg1: float): boolean
public "getScreen"(): $Screen
public "vanillaSlotRendering"(): boolean
public "setScreen"(arg0: $Screen$Type): void
public "getGuiTitle"(): $Component
public "isPauseScreen"(): boolean
public "getModularGui"(): $ModularGui
public "adoptChild"(arg0: $GuiElement$Type<(any)>): void
public "scaledScreenHeight"(): integer
public "scaledScreenWidth"(): integer
public "getParentScreen"(): $Screen
public "onTick"(arg0: $Runnable$Type): void
public "yMin"(): double
public "xMin"(): double
public "yMax"(): double
public "xMax"(): double
public "getJeiHighlightTime"(): integer
public "computeMouseX"(): double
public "computeMouseY"(): double
public "onScreenInit"(arg0: $Minecraft$Type, arg1: $Font$Type, arg2: integer, arg3: integer): void
public "mouseMoved"(arg0: double, arg1: double): void
public "onGuiClose"(): void
public "setGuiTitle"(arg0: $Component$Type): void
public "closeOnEscape"(): boolean
public "onResize"(arg0: $Runnable$Type): void
public "getDirectRoot"(): $GuiElement<(any)>
public "getSlotHandler"(arg0: $Slot$Type): $GuiElement<(any)>
public "initStandardGui"(arg0: integer, arg1: integer): $ModularGui
public "initFullscreenGui"(): $ModularGui
public "setFloatingItemDisablesToolTips"(arg0: boolean): void
public "setVanillaSlotRendering"(arg0: boolean): void
public "setJeiHighlightTime"(arg0: integer): void
/**
 * 
 * @deprecated
 */
public "createRender"(arg0: $MultiBufferSource$BufferSource$Type): $GuiRender
public "setCloseOnEscape"(arg0: boolean): void
public "setPauseScreen"(arg0: boolean): void
public "onKeyPressPre"(arg0: $TriConsumer$Type<(integer), (integer), (integer)>): void
public "onMouseClickPost"(arg0: $TriConsumer$Type<(double), (double), (integer)>): void
public "onMouseClickPre"(arg0: $TriConsumer$Type<(double), (double), (integer)>): void
public "onKeyPressPost"(arg0: $TriConsumer$Type<(integer), (integer), (integer)>): void
public "getJeiExclusions"(): $List<($GuiElement<(any)>)>
public "getJeiDropTargets"(): $List<($GuiElement<(any)>)>
public "get"(arg0: $GeoParam$Type): $GeoRef
public "getValue"(arg0: $GeoParam$Type): double
public "isDescendantOf"(arg0: $GuiElement$Type<(any)>): boolean
public "blockMouseOver"(arg0: $GuiElement$Type<(any)>, arg1: double, arg2: double): boolean
get "root"(): $GuiElement<(any)>
get "children"(): $List<($GuiElement<(any)>)>
get "provider"(): $GuiProvider
set "cursor"(value: $ResourceLocation$Type)
get "screen"(): $Screen
set "screen"(value: $Screen$Type)
get "guiTitle"(): $Component
get "pauseScreen"(): boolean
get "modularGui"(): $ModularGui
get "parentScreen"(): $Screen
get "jeiHighlightTime"(): integer
set "guiTitle"(value: $Component$Type)
get "directRoot"(): $GuiElement<(any)>
set "floatingItemDisablesToolTips"(value: boolean)
set "jeiHighlightTime"(value: integer)
set "pauseScreen"(value: boolean)
get "jeiExclusions"(): $List<($GuiElement<(any)>)>
get "jeiDropTargets"(): $List<($GuiElement<(any)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularGui$Type = ($ModularGui);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularGui_ = $ModularGui$Type;
}}
declare module "packages/codechicken/lib/render/pipeline/$VertexAttribute" {
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"
import {$AttributeKey, $AttributeKey$Type} from "packages/codechicken/lib/render/pipeline/attribute/$AttributeKey"

export class $VertexAttribute<T> implements $IVertexOperation {
 "active": boolean

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

public "operationID"(): integer
public "load"(arg0: $CCRenderState$Type): boolean
public static "registerOperation"(): integer
public static "operationCount"(): integer
public "operate"(arg0: $CCRenderState$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VertexAttribute$Type<T> = ($VertexAttribute<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VertexAttribute_<T> = $VertexAttribute$Type<(T)>;
}}
declare module "packages/codechicken/lib/render/$CCRenderState" {
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$CCRenderPipeline, $CCRenderPipeline$Type} from "packages/codechicken/lib/render/pipeline/$CCRenderPipeline"
import {$FluidStack, $FluidStack$Type} from "packages/net/minecraftforge/fluids/$FluidStack"
import {$Matrix4, $Matrix4$Type} from "packages/codechicken/lib/vec/$Matrix4"
import {$IVertexSource, $IVertexSource$Type} from "packages/codechicken/lib/render/pipeline/$IVertexSource"
import {$RenderType, $RenderType$Type} from "packages/net/minecraft/client/renderer/$RenderType"
import {$Colour, $Colour$Type} from "packages/codechicken/lib/colour/$Colour"
import {$VertexFormat$Mode, $VertexFormat$Mode$Type} from "packages/com/mojang/blaze3d/vertex/$VertexFormat$Mode"
import {$PoseStack, $PoseStack$Type} from "packages/com/mojang/blaze3d/vertex/$PoseStack"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Entity, $Entity$Type} from "packages/net/minecraft/world/entity/$Entity"
import {$VertexConsumer, $VertexConsumer$Type} from "packages/com/mojang/blaze3d/vertex/$VertexConsumer"
import {$LightMatrix, $LightMatrix$Type} from "packages/codechicken/lib/render/lighting/$LightMatrix"
import {$CachedFormat, $CachedFormat$Type} from "packages/codechicken/lib/model/$CachedFormat"
import {$VertexAttribute, $VertexAttribute$Type} from "packages/codechicken/lib/render/pipeline/$VertexAttribute"
import {$VertexFormat, $VertexFormat$Type} from "packages/com/mojang/blaze3d/vertex/$VertexFormat"
import {$LC, $LC$Type} from "packages/codechicken/lib/render/lighting/$LC"
import {$Vertex5, $Vertex5$Type} from "packages/codechicken/lib/vec/$Vertex5"
import {$ColourRGBA, $ColourRGBA$Type} from "packages/codechicken/lib/colour/$ColourRGBA"
import {$BufferBuilder, $BufferBuilder$Type} from "packages/com/mojang/blaze3d/vertex/$BufferBuilder"
import {$MultiBufferSource, $MultiBufferSource$Type} from "packages/net/minecraft/client/renderer/$MultiBufferSource"
import {$BlockAndTintGetter, $BlockAndTintGetter$Type} from "packages/net/minecraft/world/level/$BlockAndTintGetter"
import {$TextureAtlasSprite, $TextureAtlasSprite$Type} from "packages/net/minecraft/client/renderer/texture/$TextureAtlasSprite"

export class $CCRenderState {
readonly "normalAttrib": $VertexAttribute<(($Vector3)[])>
readonly "colourAttrib": $VertexAttribute<((integer)[])>
readonly "lightingAttrib": $VertexAttribute<((integer)[])>
readonly "sideAttrib": $VertexAttribute<((integer)[])>
readonly "lightCoordAttrib": $VertexAttribute<(($LC)[])>
 "model": $IVertexSource
 "firstVertexIndex": integer
 "lastVertexIndex": integer
 "vertexIndex": integer
 "pipeline": $CCRenderPipeline
 "r": $VertexConsumer
 "fmt": $VertexFormat
 "cFmt": $CachedFormat
 "baseColour": integer
 "alphaOverride": integer
 "computeLighting": boolean
 "lightMatrix": $LightMatrix
readonly "vert": $Vertex5
readonly "normal": $Vector3
 "colour": integer
 "brightness": integer
 "overlay": integer
 "side": integer
 "lc": $LC
 "sprite": $TextureAtlasSprite


public "reset"(): void
public "draw"(): void
public "render"(...arg0: ($IVertexOperation$Type)[]): void
public "render"(): void
public "setBrightness"(arg0: $Entity$Type, arg1: float): void
public "setBrightness"(arg0: $BlockAndTintGetter$Type, arg1: $BlockPos$Type): void
public "setColour"(arg0: $Colour$Type): void
public "getColour"(): $ColourRGBA
public static "instance"(): $CCRenderState
public "bind"(arg0: $BufferBuilder$Type): void
public "bind"(arg0: $RenderType$Type, arg1: $MultiBufferSource$Type, arg2: $Matrix4$Type): void
public "bind"(arg0: $VertexConsumer$Type, arg1: $VertexFormat$Type): void
public "bind"(arg0: $RenderType$Type, arg1: $MultiBufferSource$Type): void
public "bind"(arg0: $RenderType$Type, arg1: $MultiBufferSource$Type, arg2: $PoseStack$Type): void
public "setModel"(arg0: $IVertexSource$Type, arg1: integer, arg2: integer): void
public "setModel"(arg0: $IVertexSource$Type): void
public "setPipeline"(arg0: $IVertexSource$Type, arg1: integer, arg2: integer, ...arg3: ($IVertexOperation$Type)[]): void
public "setPipeline"(...arg0: ($IVertexOperation$Type)[]): void
public "startDrawing"(arg0: $VertexFormat$Mode$Type, arg1: $VertexFormat$Type): $BufferBuilder
public "startDrawing"(arg0: $VertexFormat$Mode$Type, arg1: $VertexFormat$Type, arg2: $BufferBuilder$Type): $BufferBuilder
public "getVertexFormat"(): $VertexFormat
public "runPipeline"(): void
public "setFluidColour"(arg0: $FluidStack$Type, arg1: integer): void
public "setFluidColour"(arg0: $FluidStack$Type): void
public "writeVert"(): void
public "getConsumer"(): $VertexConsumer
public "setVertexRange"(arg0: integer, arg1: integer): void
public "preRenderWorld"(arg0: $BlockAndTintGetter$Type, arg1: $BlockPos$Type): void
public "bindModel"(arg0: $IVertexSource$Type): void
set "colour"(value: $Colour$Type)
get "colour"(): $ColourRGBA
set "model"(value: $IVertexSource$Type)
set "pipeline"(value: ($IVertexOperation$Type)[])
get "vertexFormat"(): $VertexFormat
set "fluidColour"(value: $FluidStack$Type)
get "consumer"(): $VertexConsumer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CCRenderState$Type = ($CCRenderState);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CCRenderState_ = $CCRenderState$Type;
}}
declare module "packages/codechicken/lib/colour/$ColourRGBA" {
import {$Colour, $Colour$Type} from "packages/codechicken/lib/colour/$Colour"

export class $ColourRGBA extends $Colour {
 "r": byte
 "g": byte
 "b": byte
 "a": byte

constructor(arg0: $ColourRGBA$Type)
constructor(arg0: (float)[])
constructor(arg0: integer, arg1: integer, arg2: integer, arg3: integer)
constructor(arg0: double, arg1: double, arg2: double, arg3: double)
constructor(arg0: integer)

public "set"(arg0: integer): $Colour
public "copy"(): $Colour
public static "pack"(arg0: $Colour$Type): integer
public "pack"(): integer
public static "multiplyC"(arg0: integer, arg1: float): integer
public "packArray"(): (float)[]
public static "multiply"(arg0: integer, arg1: integer): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ColourRGBA$Type = ($ColourRGBA);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ColourRGBA_ = $ColourRGBA$Type;
}}
declare module "packages/codechicken/lib/colour/$Colour" {
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $Colour implements $Copyable<($Colour)> {
 "r": byte
 "g": byte
 "b": byte
 "a": byte

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

public "add"(arg0: $Colour$Type): $Colour
public "equals"(arg0: any): boolean
public "equals"(arg0: $Colour$Type): boolean
public "toString"(): string
public "hashCode"(): integer
public "scale"(arg0: double): $Colour
public "b"(): integer
public "a"(): integer
public "set"(arg0: $Colour$Type): $Colour
public "set"(arg0: integer): $Colour
public "set"(arg0: integer, arg1: integer, arg2: integer, arg3: integer): $Colour
public "set"(arg0: double, arg1: double, arg2: double, arg3: double): $Colour
public "set"(arg0: float, arg1: float, arg2: float, arg3: float): $Colour
public "set"(arg0: (double)[]): $Colour
public "set"(arg0: (float)[]): $Colour
public "g"(): integer
public "r"(): integer
public "sub"(arg0: $Colour$Type): $Colour
public "pack"(): integer
public static "pack"(arg0: (integer)[]): integer
public "bF"(arg0: integer): $Colour
public "bF"(): float
public "bF"(arg0: float): $Colour
public "invert"(): $Colour
public "interpolate"(arg0: $Colour$Type, arg1: double): $Colour
public static "unpack"(arg0: integer): (integer)[]
public "gF"(arg0: float): $Colour
public "gF"(): float
public "gF"(arg0: integer): $Colour
public "aF"(arg0: float): $Colour
public "aF"(): float
public "aF"(arg0: integer): $Colour
public "rF"(arg0: integer): $Colour
public "rF"(arg0: float): $Colour
public "rF"(): float
public "rgb"(): integer
public "getRGBA"(): (float)[]
public static "flipABGR"(arg0: integer): integer
public static "packARGB"(arg0: byte, arg1: byte, arg2: byte, arg3: byte): integer
public static "packARGB"(arg0: double, arg1: double, arg2: double, arg3: double): integer
public static "packARGB"(arg0: integer, arg1: integer, arg2: integer, arg3: integer): integer
public static "packARGB"(arg0: (float)[]): integer
public static "packRGBA"(arg0: (float)[]): integer
public static "packRGBA"(arg0: integer, arg1: integer, arg2: integer, arg3: integer): integer
public static "packRGBA"(arg0: byte, arg1: byte, arg2: byte, arg3: byte): integer
public static "packRGBA"(arg0: double, arg1: double, arg2: double, arg3: double): integer
public "getARGB"(): (float)[]
public "multiplyC"(arg0: double): $Colour
public "argb"(): integer
public "rgba"(): integer
public "packArray"(): (float)[]
public "multiply"(arg0: $Colour$Type): $Colour
get "rGBA"(): (float)[]
get "aRGB"(): (float)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Colour$Type = ($Colour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Colour_ = $Colour$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstrainedGeometry" {
import {$GeoParam, $GeoParam$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoParam"
import {$Rectangle, $Rectangle$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$Font, $Font$Type} from "packages/net/minecraft/client/gui/$Font"
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$Position, $Position$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position"
import {$GuiElement, $GuiElement$Type} from "packages/codechicken/lib/gui/modular/elements/$GuiElement"
import {$ModularGui, $ModularGui$Type} from "packages/codechicken/lib/gui/modular/$ModularGui"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Constraint, $Constraint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Constraint"
import {$Rectangle$Mutable, $Rectangle$Mutable$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Mutable"

export class $ConstrainedGeometry<T extends $ConstrainedGeometry<(T)>> implements $GuiParent<(T)> {

constructor()

public "get"(arg0: $GeoParam$Type): $GeoRef
public "validate"(): void
public "getParent"(arg0: $GeoParam$Type): $GeoRef
public "getParent"(): $GuiParent<(any)>
public "getPosition"(): $Position
public "setSize"(arg0: double, arg1: double): T
public "xSize"(): double
public "ySize"(): double
public "setHeight"(arg0: double): T
public "xCenter"(): double
public "yCenter"(): double
public "strictMode"(arg0: boolean): T
public "setWidth"(arg0: double): T
public "setPos"(arg0: double, arg1: double): T
public "yMin"(): double
public "xMin"(): double
public "yMax"(): double
public "xMax"(): double
public "constrain"(arg0: $GeoParam$Type, arg1: $Constraint$Type): T
public "clearGeometryCache"(): void
public "getEnclosingRect"(): $Rectangle$Mutable
public "getChildBounds"(): $Rectangle$Mutable
public "addBoundsToRect"(arg0: $Rectangle$Mutable$Type): $Rectangle$Mutable
public "clearConstraints"(): T
public "setXPos"(arg0: double): T
public "setYPos"(arg0: double): T
public "getRectangle"(): $Rectangle
public "getValue"(arg0: $GeoParam$Type): double
public "mc"(): $Minecraft
public "getChildren"(): $List<($GuiElement<(any)>)>
public "removeChild"(arg0: $GuiElement$Type<(any)>): void
public "font"(): $Font
public "addChild"(arg0: $Consumer$Type<(T)>): T
public "addChild"(arg0: $GuiElement$Type<(any)>): void
public "getModularGui"(): $ModularGui
public "isDescendantOf"(arg0: $GuiElement$Type<(any)>): boolean
public "adoptChild"(arg0: $GuiElement$Type<(any)>): void
public "scaledScreenHeight"(): integer
public "scaledScreenWidth"(): integer
public "blockMouseOver"(arg0: $GuiElement$Type<(any)>, arg1: double, arg2: double): boolean
public "onScreenInit"(arg0: $Minecraft$Type, arg1: $Font$Type, arg2: integer, arg3: integer): void
get "parent"(): $GuiParent<(any)>
get "position"(): $Position
set "height"(value: double)
set "width"(value: double)
get "enclosingRect"(): $Rectangle$Mutable
get "childBounds"(): $Rectangle$Mutable
set "xPos"(value: double)
set "yPos"(value: double)
get "rectangle"(): $Rectangle
get "children"(): $List<($GuiElement<(any)>)>
get "modularGui"(): $ModularGui
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstrainedGeometry$Type<T> = ($ConstrainedGeometry<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstrainedGeometry_<T> = $ConstrainedGeometry$Type<(T)>;
}}
declare module "packages/codechicken/lib/render/pipeline/attribute/$AttributeKey" {
import {$IntFunction, $IntFunction$Type} from "packages/java/util/function/$IntFunction"

export class $AttributeKey<T> {
readonly "attributeKeyIndex": integer
readonly "operationIndex": integer

constructor(arg0: string)

public "copy"(arg0: T, arg1: integer): T
public static "create"<T>(arg0: string, arg1: $IntFunction$Type<(T)>): $AttributeKey<(T)>
public "createDefault"(arg0: integer): T
public "copyRange"(arg0: T, arg1: integer, arg2: T, arg3: integer, arg4: integer): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AttributeKey$Type<T> = ($AttributeKey<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AttributeKey_<T> = $AttributeKey$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/$GuiRender$RenderWrapper" {
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$MultiBufferSource$BufferSource, $MultiBufferSource$BufferSource$Type} from "packages/net/minecraft/client/renderer/$MultiBufferSource$BufferSource"
import {$PoseStack, $PoseStack$Type} from "packages/com/mojang/blaze3d/vertex/$PoseStack"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Runnable, $Runnable$Type} from "packages/java/lang/$Runnable"
import {$GuiGraphics, $GuiGraphics$Type} from "packages/net/minecraft/client/gui/$GuiGraphics"

export class $GuiRender$RenderWrapper extends $GuiGraphics {
static readonly "MAX_GUI_Z": float
static readonly "MIN_GUI_Z": float
 "minecraft": $Minecraft
 "pose": $PoseStack
 "bufferSource": $MultiBufferSource$BufferSource
 "tooltipStack": $ItemStack


public "drawManaged"(arg0: $Runnable$Type): void
public "flush"(): void
public "flushIfUnmanaged"(): void
public "flushIfManaged"(): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiRender$RenderWrapper$Type = ($GuiRender$RenderWrapper);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiRender$RenderWrapper_ = $GuiRender$RenderWrapper$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle" {
import {$Position, $Position$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Rectangle$Mutable, $Rectangle$Mutable$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Mutable"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"
import {$Rect2i, $Rect2i$Type} from "packages/net/minecraft/client/renderer/$Rect2i"

export interface $Rectangle {

 "min"(arg0: $Axis$Type): double
 "max"(arg0: $Axis$Type): double
 "size"(arg0: $Axis$Type): double
 "x"(): double
 "contains"(arg0: double, arg1: double): boolean
 "combine"(...arg0: ($Rectangle$Type)[]): $Rectangle
 "pos"(): $Position
 "y"(): double
 "distance"(arg0: $Axis$Type, arg1: $Position$Type): double
 "offsetSize"(arg0: double, arg1: double): $Rectangle
 "setSize"(arg0: double, arg1: double): $Rectangle
 "width"(): double
 "height"(): double
 "mutable"(): $Rectangle$Mutable
 "intersects"(arg0: double, arg1: double, arg2: double, arg3: double): boolean
 "intersects"(arg0: $Rectangle$Type): boolean
 "intersect"(arg0: $Rectangle$Type): $Rectangle
 "setPos"(arg0: double, arg1: double): $Rectangle
 "offsetPos"(arg0: double, arg1: double): $Rectangle
 "yMax"(): double
 "xMax"(): double
 "toRect2i"(): $Rect2i
}

export namespace $Rectangle {
function create(arg0: $Position$Type, arg1: double, arg2: double): $Rectangle
function create(arg0: $Position$Type, arg1: $Supplier$Type<(double)>, arg2: $Supplier$Type<(double)>): $Rectangle
function create(arg0: double, arg1: double, arg2: double, arg3: double): $Rectangle
function create(arg0: $GuiParent$Type<(any)>): $Rectangle
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Rectangle$Type = ($Rectangle);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Rectangle_ = $Rectangle$Type;
}}
declare module "packages/codechicken/lib/vec/uv/$UVTransformationList" {
import {$UVTransformation, $UVTransformation$Type} from "packages/codechicken/lib/vec/uv/$UVTransformation"
import {$UV, $UV$Type} from "packages/codechicken/lib/vec/uv/$UV"

export class $UVTransformationList extends $UVTransformation {
static readonly "operationIndex": integer

constructor(...arg0: ($UVTransformation$Type)[])
constructor(arg0: $UVTransformationList$Type)

public "toString"(): string
public "apply"(arg0: $UV$Type): void
public "copy"(): $UVTransformation
public "prepend"(arg0: $UVTransformation$Type): $UVTransformationList
public "with"(arg0: $UVTransformation$Type): $UVTransformationList
public "inverse"(): $UVTransformation
public "isRedundant"(): boolean
public static "registerOperation"(): integer
public static "operationCount"(): integer
get "redundant"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UVTransformationList$Type = ($UVTransformationList);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UVTransformationList_ = $UVTransformationList$Type;
}}
declare module "packages/codechicken/lib/data/$MCDataByteBuf" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$DataInput, $DataInput$Type} from "packages/java/io/$DataInput"
import {$IForgeRegistry, $IForgeRegistry$Type} from "packages/net/minecraftforge/registries/$IForgeRegistry"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$Vector3f, $Vector3f$Type} from "packages/org/joml/$Vector3f"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$FluidStack, $FluidStack$Type} from "packages/net/minecraftforge/fluids/$FluidStack"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$CharBuffer, $CharBuffer$Type} from "packages/java/nio/$CharBuffer"
import {$MutableComponent, $MutableComponent$Type} from "packages/net/minecraft/network/chat/$MutableComponent"
import {$FloatBuffer, $FloatBuffer$Type} from "packages/java/nio/$FloatBuffer"
import {$ByteBuf, $ByteBuf$Type} from "packages/io/netty/buffer/$ByteBuf"
import {$InputStream, $InputStream$Type} from "packages/java/io/$InputStream"
import {$Cuboid6, $Cuboid6$Type} from "packages/codechicken/lib/vec/$Cuboid6"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$DoubleBuffer, $DoubleBuffer$Type} from "packages/java/nio/$DoubleBuffer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$OutputStream, $OutputStream$Type} from "packages/java/io/$OutputStream"
import {$Tag, $Tag$Type} from "packages/net/minecraft/nbt/$Tag"
import {$ShortBuffer, $ShortBuffer$Type} from "packages/java/nio/$ShortBuffer"
import {$Class, $Class$Type} from "packages/java/lang/$Class"
import {$LongBuffer, $LongBuffer$Type} from "packages/java/nio/$LongBuffer"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$ByteBuffer, $ByteBuffer$Type} from "packages/java/nio/$ByteBuffer"
import {$DataOutput, $DataOutput$Type} from "packages/java/io/$DataOutput"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$IntBuffer, $IntBuffer$Type} from "packages/java/nio/$IntBuffer"
import {$MCDataOutput, $MCDataOutput$Type} from "packages/codechicken/lib/data/$MCDataOutput"

export class $MCDataByteBuf implements $MCDataInput, $MCDataOutput {

constructor()
constructor(arg0: $ByteBuf$Type)

public "writeInt"(arg0: integer): $MCDataOutput
public "readInt"(): integer
public "writeChar"(arg0: integer): $MCDataOutput
public "readChar"(): character
public "writeFloat"(arg0: float): $MCDataOutput
public "readFloat"(): float
public "readLong"(): long
public "readByte"(): byte
public "readShort"(): short
public "writeLong"(arg0: long): $MCDataOutput
public "readBoolean"(): boolean
public "readDouble"(): double
public "writeBoolean"(arg0: boolean): $MCDataOutput
public "writeByte"(arg0: integer): $MCDataOutput
public "writeShort"(arg0: integer): $MCDataOutput
public "writeDouble"(arg0: double): $MCDataOutput
public static "readFromNBT"(arg0: $CompoundTag$Type, arg1: string): $MCDataByteBuf
public "writeToNBT"(arg0: $CompoundTag$Type, arg1: string): $CompoundTag
public "toPacketBuffer"(): $FriendlyByteBuf
public "toTag"(): $Tag
public static "fromTag"(arg0: $Tag$Type): $MCDataByteBuf
public "readUShort"(): integer
public "readUByte"(): short
public "readBytes"(): (byte)[]
public "toInputStream"(): $InputStream
public "readString"(): string
public "readEnum"<T extends $Enum<(T)>>(arg0: $Class$Type<(T)>): T
public "readInts"(): (integer)[]
public "readLongs"(): (long)[]
public "readFloats"(): (float)[]
public "readDoubles"(): (double)[]
public "readShorts"(): (short)[]
public "readChars"(): (character)[]
public "readBooleans"(): (boolean)[]
public "readRegistryId"<T>(): T
public "readFluidStack"(): $FluidStack
public "readPos"(): $BlockPos
public "readRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>): T
public "readResourceLocation"(): $ResourceLocation
public "readItemStack"(): $ItemStack
public "readVarInt"(): integer
public "readVector"(): $Vector3
public "readUUID"(): $UUID
public "readSignedVarInts"(): (integer)[]
public "readSignedVarInt"(): integer
public "readShortBuffer"(): $ShortBuffer
public "readByteBuffer"(): $ByteBuffer
public "readIntBuffer"(): $IntBuffer
public "readCharBuffer"(): $CharBuffer
public "readVarInts"(): (integer)[]
public "readVarLongs"(): (long)[]
public "readLongBuffer"(): $LongBuffer
public "readVarLong"(): long
public "readSignedVarLongs"(): (long)[]
public "readFloatBuffer"(): $FloatBuffer
public "readTextComponent"(): $MutableComponent
public "readSignedVarLong"(): long
public "readCompoundNBT"(): $CompoundTag
public "readVec3i"(): $Vec3i
public "readVec3f"(): $Vector3f
public "readDoubleBuffer"(): $DoubleBuffer
public "readCuboid"(): $Cuboid6
public "readByteBuf"(): $ByteBuf
public "toDataInput"(): $DataInput
public "readVec3d"(): $Vec3
public "readDirection"(): $Direction
public "append"(arg0: (byte)[]): $MCDataOutput
public "append"(arg0: $ByteBuf$Type): $MCDataOutput
public "writeBytes"(arg0: (byte)[]): $MCDataOutput
public "writeBytes"(arg0: (byte)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeString"(arg0: string): $MCDataOutput
public "writeString"(arg0: string, arg1: integer): $MCDataOutput
public "writeChars"(arg0: (character)[]): $MCDataOutput
public "writeChars"(arg0: (character)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeItemStack"(arg0: $ItemStack$Type): $MCDataOutput
public "writeItemStack"(arg0: $ItemStack$Type, arg1: boolean): $MCDataOutput
public "writeRegistryId"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $MCDataOutput
public "writeRegistryId"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: T): $MCDataOutput
public "writeFluidStack"(arg0: $FluidStack$Type): $MCDataOutput
public "writeShorts"(arg0: (short)[]): $MCDataOutput
public "writeShorts"(arg0: (short)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeInts"(arg0: (integer)[]): $MCDataOutput
public "writeInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeLongs"(arg0: (long)[]): $MCDataOutput
public "writeLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeFloats"(arg0: (float)[]): $MCDataOutput
public "writeFloats"(arg0: (float)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeDoubles"(arg0: (double)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeDoubles"(arg0: (double)[]): $MCDataOutput
public "writeSignedVarInt"(arg0: integer): $MCDataOutput
public "writeCharBuffer"(arg0: $CharBuffer$Type): $MCDataOutput
public "writeVarLong"(arg0: long): $MCDataOutput
public "writeUUID"(arg0: $UUID$Type): $MCDataOutput
public "writeShortBuffer"(arg0: $ShortBuffer$Type): $MCDataOutput
public "writeSignedVarInts"(arg0: (integer)[]): $MCDataOutput
public "writeSignedVarInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeByteBuffer"(arg0: $ByteBuffer$Type): $MCDataOutput
public "writeLongBuffer"(arg0: $LongBuffer$Type): $MCDataOutput
public "writeFloatBuffer"(arg0: $FloatBuffer$Type): $MCDataOutput
public "writeVarInts"(arg0: (integer)[]): $MCDataOutput
public "writeVarInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeDoubleBuffer"(arg0: $DoubleBuffer$Type): $MCDataOutput
public "writeVarLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeVarLongs"(arg0: (long)[]): $MCDataOutput
public "writeIntBuffer"(arg0: $IntBuffer$Type): $MCDataOutput
public "writeSignedVarLong"(arg0: long): $MCDataOutput
public "writeCuboid"(arg0: $Cuboid6$Type): $MCDataOutput
public "writeCompoundNBT"(arg0: $CompoundTag$Type): $MCDataOutput
public "writeVec3d"(arg0: $Vec3$Type): $MCDataOutput
public "writeVec3f"(arg0: $Vector3f$Type): $MCDataOutput
public "writeTextComponent"(arg0: $Component$Type): $MCDataOutput
public "toDataOutput"(): $DataOutput
public "writeVec3i"(arg0: $Vec3i$Type): $MCDataOutput
public "writeDirection"(arg0: $Direction$Type): $MCDataOutput
public "writeByteBuf"(arg0: $ByteBuf$Type): $MCDataOutput
public "writeVector"(arg0: $Vector3$Type): $MCDataOutput
public "toOutputStream"(): $OutputStream
public "writeBooleans"(arg0: (boolean)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeBooleans"(arg0: (boolean)[]): $MCDataOutput
public "writePos"(arg0: $BlockPos$Type): $MCDataOutput
public "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: T): $MCDataOutput
public "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $MCDataOutput
public "writeResourceLocation"(arg0: $ResourceLocation$Type): $MCDataOutput
public "writeSignedVarLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
public "writeSignedVarLongs"(arg0: (long)[]): $MCDataOutput
public "writeEnum"(arg0: $Enum$Type<(any)>): $MCDataOutput
public "writeVarInt"(arg0: integer): $MCDataOutput
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MCDataByteBuf$Type = ($MCDataByteBuf);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MCDataByteBuf_ = $MCDataByteBuf$Type;
}}
declare module "packages/codechicken/lib/model/$CachedFormat" {
import {$VertexFormat, $VertexFormat$Type} from "packages/com/mojang/blaze3d/vertex/$VertexFormat"

export class $CachedFormat {
static readonly "BLOCK": $CachedFormat
readonly "format": $VertexFormat
readonly "hasPosition": boolean
readonly "hasNormal": boolean
readonly "hasColor": boolean
readonly "hasUV": boolean
readonly "hasOverlay": boolean
readonly "hasLightMap": boolean
readonly "positionIndex": integer
readonly "normalIndex": integer
readonly "colorIndex": integer
readonly "uvIndex": integer
readonly "overlayIndex": integer
readonly "lightMapIndex": integer
readonly "elementCount": integer


public "equals"(arg0: any): boolean
public "hashCode"(): integer
public static "lookup"(arg0: $VertexFormat$Type): $CachedFormat
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CachedFormat$Type = ($CachedFormat);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CachedFormat_ = $CachedFormat$Type;
}}
declare module "packages/codechicken/lib/inventory/container/data/$AbstractDataStore" {
import {$Tag, $Tag$Type} from "packages/net/minecraft/nbt/$Tag"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$MCDataOutput, $MCDataOutput$Type} from "packages/codechicken/lib/data/$MCDataOutput"

export class $AbstractDataStore<T> {

constructor(arg0: T)

public "get"(): T
public "toBytes"(arg0: $MCDataOutput$Type): void
public "set"(arg0: T): void
public "fromBytes"(arg0: $MCDataInput$Type): void
public "markDirty"(): void
public "toTag"(): $Tag
public "fromTag"(arg0: $Tag$Type): void
public "isSameValue"(arg0: T): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AbstractDataStore$Type<T> = ($AbstractDataStore<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AbstractDataStore_<T> = $AbstractDataStore$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/$TooltipHandler" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$GuiRender, $GuiRender$Type} from "packages/codechicken/lib/gui/modular/lib/$GuiRender"

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

 "renderTooltip"(arg0: $GuiRender$Type, arg1: double, arg2: double): boolean
 "getTooltip"(): $Supplier<($List<($Component)>)>
 "setTooltip"(arg0: $Supplier$Type<($List$Type<($Component$Type)>)>): T
 "setTooltip"(arg0: $List$Type<($Component$Type)>): T
 "setTooltip"(arg0: $Supplier$Type<($List$Type<($Component$Type)>)>, arg1: integer): T
 "setTooltip"(...arg0: ($Component$Type)[]): T
 "setTooltipDelay"(arg0: integer): T
 "getTooltipDelay"(): integer
 "setTooltipSingle"(arg0: $Component$Type): T
 "setTooltipSingle"(arg0: $Supplier$Type<($Component$Type)>): T
}

export namespace $TooltipHandler {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TooltipHandler$Type<T> = ($TooltipHandler<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TooltipHandler_<T> = $TooltipHandler$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/elements/$GuiElement" {
import {$ElementEvents, $ElementEvents$Type} from "packages/codechicken/lib/gui/modular/lib/$ElementEvents"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$ConstrainedGeometry, $ConstrainedGeometry$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstrainedGeometry"
import {$Rectangle, $Rectangle$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TooltipHandler, $TooltipHandler$Type} from "packages/codechicken/lib/gui/modular/lib/$TooltipHandler"
import {$GuiRender, $GuiRender$Type} from "packages/codechicken/lib/gui/modular/lib/$GuiRender"
import {$Font, $Font$Type} from "packages/net/minecraft/client/gui/$Font"
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$ModularGui, $ModularGui$Type} from "packages/codechicken/lib/gui/modular/$ModularGui"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"

export class $GuiElement<T extends $GuiElement<(T)>> extends $ConstrainedGeometry<(T)> implements $ElementEvents, $TooltipHandler<(T)> {
 "initialized": boolean

constructor(arg0: $GuiParent$Type<(any)>)

public "toString"(): string
public "getParent"(): $GuiParent<(any)>
public "mc"(): $Minecraft
public "setOpaque"(arg0: boolean): T
public "isOpaque"(): boolean
public "getChildren"(): $List<($GuiElement<(any)>)>
public "tick"(arg0: double, arg1: double): void
public "isEnabled"(): boolean
public "removeChild"(arg0: $GuiElement$Type<(any)>): void
public "font"(): $Font
public "render"(arg0: $GuiRender$Type, arg1: double, arg2: double, arg3: float): void
public "addChild"(arg0: $GuiElement$Type<(any)>): void
public "isRemoved"(): boolean
public "setEnabled"(arg0: boolean): T
public "setEnabled"(arg0: $Supplier$Type<(boolean)>): T
public "renderOverlay"(arg0: $GuiRender$Type, arg1: double, arg2: double, arg3: float, arg4: boolean): boolean
public "isMouseOver"(): boolean
public "updateMouseOver"(arg0: double, arg1: double, arg2: boolean): boolean
public "getModularGui"(): $ModularGui
public "isDescendantOf"(arg0: $GuiElement$Type<(any)>): boolean
public "adoptChild"(arg0: $GuiElement$Type<(any)>): void
public "scaledScreenHeight"(): integer
public "scaledScreenWidth"(): integer
public "blockMouseOver"(arg0: $GuiElement$Type<(any)>, arg1: double, arg2: double): boolean
public "getTooltip"(): $Supplier<($List<($Component)>)>
public "setTooltip"(arg0: $Supplier$Type<($List$Type<($Component$Type)>)>): T
public "bringChildToForeground"(arg0: $GuiElement$Type<(any)>): void
public "sendChildToBackground"(arg0: $GuiElement$Type<(any)>): void
public "getCombinedElementDepth"(): double
public "onScreenInit"(arg0: $Minecraft$Type, arg1: $Font$Type, arg2: integer, arg3: integer): void
public "jeiExclude"(): T
public "initElement"(arg0: $GuiParent$Type<(any)>): void
public "zStacking"(): boolean
public "isJeiExcluded"(): boolean
public "hoverTime"(): integer
public "sendChildToIndex"(arg0: $GuiElement$Type<(any)>, arg1: integer): void
public "isTooltipEnabled"(): boolean
public "showToolTip"(): boolean
public "getTooltipDelay"(): integer
public "setJeiExcluded"(arg0: boolean): T
public "setJeiDropTarget"(arg0: $Consumer$Type<($ItemStack$Type)>, arg1: boolean): T
public "blockMouseEvents"(): boolean
public "setEnableToolTip"(arg0: $Supplier$Type<(boolean)>): T
public "setZStacking"(arg0: boolean): T
public "setRenderCull"(arg0: $Rectangle$Type): T
public "getJeiDropConsumer"(): $Consumer<($ItemStack)>
public "addJeiExclusions"(arg0: $List$Type<($GuiElement$Type<(any)>)>): $List<($GuiElement<(any)>)>
public "isJeiDropTarget"(): boolean
public "addJeiDropTargets"(arg0: $List$Type<($GuiElement$Type<(any)>)>): $List<($GuiElement<(any)>)>
public "keyReleased"(arg0: integer, arg1: integer, arg2: integer): boolean
public "keyReleased"(arg0: integer, arg1: integer, arg2: integer, arg3: boolean): boolean
public "charTyped"(arg0: character, arg1: integer): boolean
public "charTyped"(arg0: character, arg1: integer, arg2: boolean): boolean
public "mouseClicked"(arg0: double, arg1: double, arg2: integer, arg3: boolean): boolean
public "mouseClicked"(arg0: double, arg1: double, arg2: integer): boolean
public "mouseReleased"(arg0: double, arg1: double, arg2: integer): boolean
public "mouseReleased"(arg0: double, arg1: double, arg2: integer, arg3: boolean): boolean
public "keyPressed"(arg0: integer, arg1: integer, arg2: integer, arg3: boolean): boolean
public "keyPressed"(arg0: integer, arg1: integer, arg2: integer): boolean
public "mouseScrolled"(arg0: double, arg1: double, arg2: double, arg3: boolean): boolean
public "mouseScrolled"(arg0: double, arg1: double, arg2: double): boolean
public "mouseMoved"(arg0: double, arg1: double): void
public "renderTooltip"(arg0: $GuiRender$Type, arg1: double, arg2: double): boolean
public "setTooltip"(arg0: $List$Type<($Component$Type)>): T
public "setTooltip"(arg0: $Supplier$Type<($List$Type<($Component$Type)>)>, arg1: integer): T
public "setTooltip"(...arg0: ($Component$Type)[]): T
public "setTooltipSingle"(arg0: $Component$Type): T
public "setTooltipSingle"(arg0: $Supplier$Type<($Component$Type)>): T
get "parent"(): $GuiParent<(any)>
set "opaque"(value: boolean)
get "opaque"(): boolean
get "children"(): $List<($GuiElement<(any)>)>
get "enabled"(): boolean
get "removed"(): boolean
set "enabled"(value: boolean)
set "enabled"(value: $Supplier$Type<(boolean)>)
get "mouseOver"(): boolean
get "modularGui"(): $ModularGui
get "tooltip"(): $Supplier<($List<($Component)>)>
set "tooltip"(value: $Supplier$Type<($List$Type<($Component$Type)>)>)
get "combinedElementDepth"(): double
get "jeiExcluded"(): boolean
get "tooltipEnabled"(): boolean
get "tooltipDelay"(): integer
set "jeiExcluded"(value: boolean)
set "enableToolTip"(value: $Supplier$Type<(boolean)>)
set "renderCull"(value: $Rectangle$Type)
get "jeiDropConsumer"(): $Consumer<($ItemStack)>
get "jeiDropTarget"(): boolean
set "tooltip"(value: $List$Type<($Component$Type)>)
set "tooltip"(value: ($Component$Type)[])
set "tooltipSingle"(value: $Component$Type)
set "tooltipSingle"(value: $Supplier$Type<($Component$Type)>)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiElement$Type<T> = ($GuiElement<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiElement_<T> = $GuiElement$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Position$Mutable" {
import {$Position, $Position$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"

export class $Position$Mutable implements $Position {

constructor(arg0: double, arg1: double)

public "toString"(): string
public "offset"(arg0: double, arg1: double): $Position
public "x"(): double
public "set"(arg0: double, arg1: double): $Position
public "y"(): double
public "get"(arg0: $Axis$Type): double
public static "create"(arg0: $GuiParent$Type<(any)>): $Position
public static "create"(arg0: double, arg1: double): $Position
public static "create"(arg0: $Supplier$Type<(double)>, arg1: $Supplier$Type<(double)>): $Position
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Position$Mutable$Type = ($Position$Mutable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Position$Mutable_ = $Position$Mutable$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$MidPointDynamic extends $ConstraintImpl<($ConstraintImpl$MidPointDynamic)> {

constructor(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>)

public "getOffset"(): double
public "getStart"(): double
public "getEnd"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "offset"(): double
get "start"(): double
get "end"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$MidPointDynamic$Type = ($ConstraintImpl$MidPointDynamic);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$MidPointDynamic_ = $ConstraintImpl$MidPointDynamic$Type;
}}
declare module "packages/codechicken/lib/render/lighting/$LightMatrix" {
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$BlockAndTintGetter, $BlockAndTintGetter$Type} from "packages/net/minecraft/world/level/$BlockAndTintGetter"

export class $LightMatrix implements $IVertexOperation {
static readonly "operationIndex": integer
 "computed": integer
 "ao": ((float)[])[]
 "brightness": ((integer)[])[]
 "access": $BlockAndTintGetter
 "pos": $BlockPos
static readonly "ssamplem": ((integer)[])[]
static readonly "qsamplem": ((integer)[])[]
static readonly "sideao": (float)[]

constructor()

public "load"(arg0: $CCRenderState$Type): boolean
public "ao"(arg0: integer): (float)[]
public "locate"(arg0: $BlockAndTintGetter$Type, arg1: $BlockPos$Type): void
public "brightness"(arg0: integer): (integer)[]
public "sample"(arg0: integer): void
public "operationID"(): integer
public "operate"(arg0: $CCRenderState$Type): void
public "sideSample"(arg0: integer): void
public static "interpAO"(arg0: float, arg1: float, arg2: float, arg3: float): float
public static "interpBrightness"(arg0: integer, arg1: integer, arg2: integer, arg3: integer): integer
public static "registerOperation"(): integer
public static "operationCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LightMatrix$Type = ($LightMatrix);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LightMatrix_ = $LightMatrix$Type;
}}
declare module "packages/codechicken/lib/render/lighting/$LC" {
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $LC implements $Copyable<($LC)> {
 "side": integer
 "fa": float
 "fb": float
 "fc": float
 "fd": float

constructor()
constructor(arg0: integer, arg1: float, arg2: float, arg3: float, arg4: float)

public "compute"(arg0: $Vector3$Type, arg1: $Vector3$Type): $LC
public "compute"(arg0: $Vector3$Type, arg1: integer): $LC
public "set"(arg0: $LC$Type): $LC
public "set"(arg0: integer, arg1: float, arg2: float, arg3: float, arg4: float): $LC
public "copy"(): $LC
public "computeO"(arg0: $Vector3$Type, arg1: integer): $LC
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LC$Type = ($LC);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LC_ = $LC$Type;
}}
declare module "packages/codechicken/lib/vec/$Rotation" {
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Quat, $Quat$Type} from "packages/codechicken/lib/vec/$Quat"
import {$Matrix4, $Matrix4$Type} from "packages/codechicken/lib/vec/$Matrix4"
import {$LivingEntity, $LivingEntity$Type} from "packages/net/minecraft/world/entity/$LivingEntity"

export class $Rotation extends $Transformation {
static "quarterRotations": ($Transformation)[]
static "sideRotations": ($Transformation)[]
static "axes": ($Vector3)[]
static "sideRotMap": (integer)[]
static "rotSideMap": (integer)[]
static "sideRotOffsets": (integer)[]
 "angle": double
 "axis": $Vector3
static readonly "operationIndex": integer

constructor(arg0: double, arg1: $Vector3$Type)
constructor(arg0: double, arg1: double, arg2: double, arg3: double)
constructor(arg0: $Quat$Type)
constructor(arg0: $Rotation$Type)

public "toString"(): string
public "apply"(arg0: $Vector3$Type): void
public "apply"(arg0: $Matrix4$Type): void
public "merge"(arg0: $Transformation$Type): $Transformation
public "copy"(): $Rotation
public static "rotationTo"(arg0: integer, arg1: integer): integer
public static "rotateSide"(arg0: integer, arg1: integer): integer
public static "getSidedRotation"(arg0: $Player$Type, arg1: integer): integer
public static "sideOrientation"(arg0: integer, arg1: integer): $Transformation
public "toQuat"(): $Quat
public "isRedundant"(): boolean
public "applyN"(arg0: $Vector3$Type): void
public static "getSideFromLookAngle"(arg0: $LivingEntity$Type): integer
public static "registerOperation"(): integer
public static "operationCount"(): integer
get "redundant"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Rotation$Type = ($Rotation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Rotation_ = $Rotation$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/container/$DataSync" {
import {$ModularGuiContainerMenu, $ModularGuiContainerMenu$Type} from "packages/codechicken/lib/inventory/container/modular/$ModularGuiContainerMenu"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$AbstractDataStore, $AbstractDataStore$Type} from "packages/codechicken/lib/inventory/container/data/$AbstractDataStore"

export class $DataSync<T> {
static readonly "PKT_SEND_CHANGES": integer

constructor(arg0: $ModularGuiContainerMenu$Type, arg1: $AbstractDataStore$Type<(T)>, arg2: $Supplier$Type<(T)>)

public "get"(): T
public "detectAndSend"(): void
public "handleSyncPacket"(arg0: $MCDataInput$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DataSync$Type<T> = ($DataSync<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DataSync_<T> = $DataSync$Type<(T)>;
}}
declare module "packages/codechicken/lib/inventory/container/$ICCLContainerType$CCLContainerType" {
import {$LecternMenu, $LecternMenu$Type} from "packages/net/minecraft/world/inventory/$LecternMenu"
import {$DispenserMenu, $DispenserMenu$Type} from "packages/net/minecraft/world/inventory/$DispenserMenu"
import {$SmithingMenu, $SmithingMenu$Type} from "packages/net/minecraft/world/inventory/$SmithingMenu"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$FeatureFlagSet, $FeatureFlagSet$Type} from "packages/net/minecraft/world/flag/$FeatureFlagSet"
import {$IContainerFactory, $IContainerFactory$Type} from "packages/net/minecraftforge/network/$IContainerFactory"
import {$GrindstoneMenu, $GrindstoneMenu$Type} from "packages/net/minecraft/world/inventory/$GrindstoneMenu"
import {$LoomMenu, $LoomMenu$Type} from "packages/net/minecraft/world/inventory/$LoomMenu"
import {$MerchantMenu, $MerchantMenu$Type} from "packages/net/minecraft/world/inventory/$MerchantMenu"
import {$MenuType$MenuSupplier, $MenuType$MenuSupplier$Type} from "packages/net/minecraft/world/inventory/$MenuType$MenuSupplier"
import {$BeaconMenu, $BeaconMenu$Type} from "packages/net/minecraft/world/inventory/$BeaconMenu"
import {$StonecutterMenu, $StonecutterMenu$Type} from "packages/net/minecraft/world/inventory/$StonecutterMenu"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$ChestMenu, $ChestMenu$Type} from "packages/net/minecraft/world/inventory/$ChestMenu"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$SmokerMenu, $SmokerMenu$Type} from "packages/net/minecraft/world/inventory/$SmokerMenu"
import {$FurnaceMenu, $FurnaceMenu$Type} from "packages/net/minecraft/world/inventory/$FurnaceMenu"
import {$AnvilMenu, $AnvilMenu$Type} from "packages/net/minecraft/world/inventory/$AnvilMenu"
import {$CraftingMenu, $CraftingMenu$Type} from "packages/net/minecraft/world/inventory/$CraftingMenu"
import {$CartographyTableMenu, $CartographyTableMenu$Type} from "packages/net/minecraft/world/inventory/$CartographyTableMenu"
import {$ShulkerBoxMenu, $ShulkerBoxMenu$Type} from "packages/net/minecraft/world/inventory/$ShulkerBoxMenu"
import {$EnchantmentMenu, $EnchantmentMenu$Type} from "packages/net/minecraft/world/inventory/$EnchantmentMenu"
import {$HopperMenu, $HopperMenu$Type} from "packages/net/minecraft/world/inventory/$HopperMenu"
import {$ICCLContainerType, $ICCLContainerType$Type} from "packages/codechicken/lib/inventory/container/$ICCLContainerType"
import {$BrewingStandMenu, $BrewingStandMenu$Type} from "packages/net/minecraft/world/inventory/$BrewingStandMenu"
import {$BlastFurnaceMenu, $BlastFurnaceMenu$Type} from "packages/net/minecraft/world/inventory/$BlastFurnaceMenu"
import {$ICCLContainerFactory, $ICCLContainerFactory$Type} from "packages/codechicken/lib/inventory/container/$ICCLContainerFactory"
import {$FeatureFlag, $FeatureFlag$Type} from "packages/net/minecraft/world/flag/$FeatureFlag"

export class $ICCLContainerType$CCLContainerType<T extends $AbstractContainerMenu> extends $MenuType<(T)> implements $ICCLContainerType<(T)> {
static readonly "GENERIC_9x1": $MenuType<($ChestMenu)>
static readonly "GENERIC_9x2": $MenuType<($ChestMenu)>
static readonly "GENERIC_9x3": $MenuType<($ChestMenu)>
static readonly "GENERIC_9x4": $MenuType<($ChestMenu)>
static readonly "GENERIC_9x5": $MenuType<($ChestMenu)>
static readonly "GENERIC_9x6": $MenuType<($ChestMenu)>
static readonly "GENERIC_3x3": $MenuType<($DispenserMenu)>
static readonly "ANVIL": $MenuType<($AnvilMenu)>
static readonly "BEACON": $MenuType<($BeaconMenu)>
static readonly "BLAST_FURNACE": $MenuType<($BlastFurnaceMenu)>
static readonly "BREWING_STAND": $MenuType<($BrewingStandMenu)>
static readonly "CRAFTING": $MenuType<($CraftingMenu)>
static readonly "ENCHANTMENT": $MenuType<($EnchantmentMenu)>
static readonly "FURNACE": $MenuType<($FurnaceMenu)>
static readonly "GRINDSTONE": $MenuType<($GrindstoneMenu)>
static readonly "HOPPER": $MenuType<($HopperMenu)>
static readonly "LECTERN": $MenuType<($LecternMenu)>
static readonly "LOOM": $MenuType<($LoomMenu)>
static readonly "MERCHANT": $MenuType<($MerchantMenu)>
static readonly "SHULKER_BOX": $MenuType<($ShulkerBoxMenu)>
static readonly "SMITHING": $MenuType<($SmithingMenu)>
static readonly "SMOKER": $MenuType<($SmokerMenu)>
static readonly "CARTOGRAPHY_TABLE": $MenuType<($CartographyTableMenu)>
static readonly "STONECUTTER": $MenuType<($StonecutterMenu)>
readonly "constructor": $MenuType$MenuSupplier<(T)>

constructor(arg0: $MenuType$MenuSupplier$Type<(T)>, arg1: $FeatureFlagSet$Type)

public "create"(arg0: integer, arg1: $Inventory$Type, arg2: $MCDataInput$Type): T
public static "create"<T extends $AbstractContainerMenu>(arg0: $ICCLContainerFactory$Type<(T)>): $MenuType<(T)>
public static "create"<T extends $AbstractContainerMenu>(arg0: $ICCLContainerFactory$Type<(T)>, ...arg1: ($FeatureFlag$Type)[]): $MenuType<(T)>
public static "create"<T extends $AbstractContainerMenu>(arg0: $IContainerFactory$Type<(T)>): $MenuType<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICCLContainerType$CCLContainerType$Type<T> = ($ICCLContainerType$CCLContainerType<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICCLContainerType$CCLContainerType_<T> = $ICCLContainerType$CCLContainerType$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"

export class $ConstraintImpl$RelativeDynamic extends $ConstraintImpl<($ConstraintImpl$RelativeDynamic)> {

constructor(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>)

public "getOffset"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "offset"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$RelativeDynamic$Type = ($ConstraintImpl$RelativeDynamic);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$RelativeDynamic_ = $ConstraintImpl$RelativeDynamic$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/$GuiRender" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$MultiBufferSource$BufferSource, $MultiBufferSource$BufferSource$Type} from "packages/net/minecraft/client/renderer/$MultiBufferSource$BufferSource"
import {$Rectangle, $Rectangle$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle"
import {$Borders, $Borders$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Borders"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$GuiGraphics, $GuiGraphics$Type} from "packages/net/minecraft/client/gui/$GuiGraphics"
import {$ClientTooltipPositioner, $ClientTooltipPositioner$Type} from "packages/net/minecraft/client/gui/screens/inventory/tooltip/$ClientTooltipPositioner"
import {$Runnable, $Runnable$Type} from "packages/java/lang/$Runnable"
import {$LivingEntity, $LivingEntity$Type} from "packages/net/minecraft/world/entity/$LivingEntity"
import {$GuiRender$RenderWrapper, $GuiRender$RenderWrapper$Type} from "packages/codechicken/lib/gui/modular/lib/$GuiRender$RenderWrapper"
import {$RenderType, $RenderType$Type} from "packages/net/minecraft/client/renderer/$RenderType"
import {$Material, $Material$Type} from "packages/codechicken/lib/gui/modular/sprite/$Material"
import {$TooltipComponent, $TooltipComponent$Type} from "packages/net/minecraft/world/inventory/tooltip/$TooltipComponent"
import {$FormattedText, $FormattedText$Type} from "packages/net/minecraft/network/chat/$FormattedText"
import {$PoseStack, $PoseStack$Type} from "packages/com/mojang/blaze3d/vertex/$PoseStack"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FormattedCharSequence, $FormattedCharSequence$Type} from "packages/net/minecraft/util/$FormattedCharSequence"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$Style, $Style$Type} from "packages/net/minecraft/network/chat/$Style"
import {$Font, $Font$Type} from "packages/net/minecraft/client/gui/$Font"
import {$Minecraft, $Minecraft$Type} from "packages/net/minecraft/client/$Minecraft"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$TextureAtlasSprite, $TextureAtlasSprite$Type} from "packages/net/minecraft/client/renderer/texture/$TextureAtlasSprite"

export class $GuiRender {
static readonly "SOLID": $RenderType

constructor(arg0: $Minecraft$Type, arg1: $PoseStack$Type, arg2: $MultiBufferSource$BufferSource$Type)
constructor(arg0: $Minecraft$Type, arg1: $MultiBufferSource$BufferSource$Type)

public static "convert"(arg0: $GuiGraphics$Type): $GuiRender
public "flush"(): void
public "fill"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer): void
public "fill"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer): void
public "mc"(): $Minecraft
public "buffers"(): $MultiBufferSource$BufferSource
public "setColor"(arg0: float, arg1: float, arg2: float, arg3: float): void
public "font"(): $Font
public "tex"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double): void
public "tex"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer): void
public "tex"(arg0: $Material$Type, arg1: integer, arg2: double, arg3: double, arg4: double, arg5: double): void
public "tex"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: float, arg6: float, arg7: float, arg8: float): void
public "tex"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: float, arg7: float, arg8: float, arg9: float): void
public "tex"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer): void
public "drawString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean): integer
public "drawString"(arg0: string, arg1: double, arg2: double, arg3: integer): integer
public "drawString"(arg0: string, arg1: double, arg2: double, arg3: integer, arg4: boolean): integer
public "drawString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: integer): integer
public "drawString"(arg0: $FormattedCharSequence$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean): integer
public "drawString"(arg0: $FormattedCharSequence$Type, arg1: double, arg2: double, arg3: integer): integer
public "guiHeight"(): integer
public "guiWidth"(): integer
public "renderItem"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: double): void
public "renderItem"(arg0: $ItemStack$Type, arg1: double, arg2: double): void
public "renderItem"(arg0: $LivingEntity$Type, arg1: $Level$Type, arg2: $ItemStack$Type, arg3: double, arg4: double, arg5: double, arg6: integer): void
public "renderItem"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: double, arg4: integer): void
public "renderItem"(arg0: $LivingEntity$Type, arg1: $ItemStack$Type, arg2: double, arg3: double, arg4: integer): void
public "renderItem"(arg0: $LivingEntity$Type, arg1: $ItemStack$Type, arg2: double, arg3: double, arg4: double, arg5: integer): void
public "renderTooltip"(arg0: $Component$Type, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
public "renderTooltip"(arg0: $List$Type<(any)>, arg1: double, arg2: double): void
public "renderTooltip"(arg0: $List$Type<($FormattedCharSequence$Type)>, arg1: $ClientTooltipPositioner$Type, arg2: double, arg3: double, arg4: integer, arg5: integer, arg6: integer, arg7: integer): void
public "renderTooltip"(arg0: $List$Type<(any)>, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
public "renderTooltip"(arg0: $ItemStack$Type, arg1: double, arg2: double): void
public "renderTooltip"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
public "renderTooltip"(arg0: $Component$Type, arg1: double, arg2: double): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type, arg7: float, arg8: float, arg9: float, arg10: float): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type, arg7: integer): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: float, arg7: float, arg8: float, arg9: float): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: integer): void
public "sprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type): void
public "toolTipBackground"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: boolean): void
public "toolTipBackground"(arg0: double, arg1: double, arg2: double, arg3: double): void
public "toolTipBackground"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: integer, arg6: integer): void
public "pose"(): $PoseStack
public "popScissor"(): void
public "pushScissor"(arg0: double, arg1: double, arg2: double, arg3: double): void
public "rect"(arg0: $Rectangle$Type, arg1: integer): void
public "rect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer): void
public "rect"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer): void
public "rect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: integer): void
public "drawCenteredString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean): void
public "drawCenteredString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: integer): void
public "drawCenteredString"(arg0: string, arg1: double, arg2: double, arg3: integer): void
public "drawCenteredString"(arg0: string, arg1: double, arg2: double, arg3: integer, arg4: boolean): void
public "drawCenteredString"(arg0: $FormattedCharSequence$Type, arg1: double, arg2: double, arg3: integer): void
public "drawCenteredString"(arg0: $FormattedCharSequence$Type, arg1: double, arg2: double, arg3: integer, arg4: boolean): void
public static "texColType"(arg0: $ResourceLocation$Type): $RenderType
public "partialSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: float, arg7: float, arg8: float, arg9: float, arg10: integer): void
public "partialSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: float, arg7: float, arg8: float, arg9: float, arg10: float, arg11: float, arg12: float, arg13: float): void
public "texRect"(arg0: $Material$Type, arg1: integer, arg2: $Rectangle$Type, arg3: integer): void
public "texRect"(arg0: $Material$Type, arg1: integer, arg2: $Rectangle$Type): void
public "texRect"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: float, arg6: float, arg7: float, arg8: float): void
public "texRect"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer): void
public "texRect"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: float, arg7: float, arg8: float, arg9: float): void
public "texRect"(arg0: $Material$Type, arg1: integer, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer): void
public "texRect"(arg0: $Material$Type, arg1: integer, arg2: double, arg3: double, arg4: double, arg5: double): void
public "texRect"(arg0: $Material$Type, arg1: integer, arg2: $Rectangle$Type, arg3: float, arg4: float, arg5: float, arg6: float): void
public "texRect"(arg0: $Material$Type, arg1: $Rectangle$Type): void
public "texRect"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: integer): void
public "texRect"(arg0: $Material$Type, arg1: double, arg2: double, arg3: double, arg4: double): void
public "texRect"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: float, arg3: float, arg4: float, arg5: float): void
public "drawScrollingString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: boolean): void
public "drawScrollingString"(arg0: $Component$Type, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: boolean, arg6: boolean): void
public "renderItemDecorations"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: double, arg4: string): void
public "renderItemDecorations"(arg0: $ItemStack$Type, arg1: double, arg2: double): void
public "renderItemDecorations"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: string): void
public "renderItemDecorations"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: double): void
public "componentTooltip"(arg0: $List$Type<($Component$Type)>, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
public "componentTooltip"(arg0: $List$Type<(any)>, arg1: double, arg2: double, arg3: $ItemStack$Type): void
public "componentTooltip"(arg0: $List$Type<(any)>, arg1: double, arg2: double): void
public "componentTooltip"(arg0: $List$Type<(any)>, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: $ItemStack$Type): void
public static "isInRect"(arg0: integer, arg1: integer, arg2: integer, arg3: integer, arg4: double, arg5: double): boolean
public static "isInRect"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double): boolean
public "borderRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: double, arg3: integer, arg4: integer): void
public "borderRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer, arg7: integer): void
public "borderRect"(arg0: $Rectangle$Type, arg1: double, arg2: integer, arg3: integer): void
public "borderRect"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer): void
public static "mixColours"(arg0: integer, arg1: integer): integer
public static "mixColours"(arg0: integer, arg1: integer, arg2: boolean): integer
public "shadedRect"(arg0: $Rectangle$Type, arg1: double, arg2: integer, arg3: integer, arg4: integer): void
public "shadedRect"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer, arg7: integer): void
public "shadedRect"(arg0: $Rectangle$Type, arg1: double, arg2: integer, arg3: integer, arg4: integer, arg5: integer): void
public "shadedRect"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer, arg7: integer, arg8: integer): void
public "shadedRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
public "dynamicTex"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: $Borders$Type, arg3: integer): void
public "dynamicTex"(arg0: $Material$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: float, arg10: float, arg11: float, arg12: float): void
public "dynamicTex"(arg0: $Material$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer): void
public "dynamicTex"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer): void
public "dynamicTex"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: integer, arg3: integer, arg4: integer, arg5: integer): void
public "dynamicTex"(arg0: $Material$Type, arg1: $Rectangle$Type, arg2: $Borders$Type): void
public "dynamicTex"(arg0: $Material$Type, arg1: integer, arg2: integer, arg3: integer, arg4: integer, arg5: integer, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
public "pushScissorRect"(arg0: double, arg1: double, arg2: double, arg3: double): void
public "pushScissorRect"(arg0: $Rectangle$Type): void
public static "midColour"(arg0: integer, arg1: integer): integer
public "renderFakeItem"(arg0: $ItemStack$Type, arg1: double, arg2: double): void
public "renderFakeItem"(arg0: $ItemStack$Type, arg1: double, arg2: double, arg3: double): void
public "toolTipWithImage"(arg0: $List$Type<($Component$Type)>, arg1: $Optional$Type<($TooltipComponent$Type)>, arg2: $ItemStack$Type, arg3: double, arg4: double): void
public "toolTipWithImage"(arg0: $List$Type<($Component$Type)>, arg1: $Optional$Type<($TooltipComponent$Type)>, arg2: $ItemStack$Type, arg3: double, arg4: double, arg5: integer, arg6: integer, arg7: integer, arg8: integer): void
public "toolTipWithImage"(arg0: $List$Type<($Component$Type)>, arg1: $Optional$Type<($TooltipComponent$Type)>, arg2: double, arg3: double): void
public "toolTipWithImage"(arg0: $List$Type<($Component$Type)>, arg1: $Optional$Type<($TooltipComponent$Type)>, arg2: double, arg3: double, arg4: integer, arg5: integer, arg6: integer, arg7: integer): void
public "drawWordWrap"(arg0: $FormattedText$Type, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: boolean): void
public "drawWordWrap"(arg0: $FormattedText$Type, arg1: double, arg2: double, arg3: integer, arg4: integer, arg5: boolean, arg6: double): void
public "drawWordWrap"(arg0: $FormattedText$Type, arg1: double, arg2: double, arg3: integer, arg4: integer): void
public "renderComponentHoverEffect"(arg0: $Style$Type, arg1: integer, arg2: integer): void
public "borderFill"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer): void
public "borderFill"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer, arg7: integer): void
/**
 * 
 * @deprecated
 */
public "guiGraphicsWrapper"(): $GuiRender$RenderWrapper
public "gradientFillH"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: integer): void
public "gradientFillH"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer): void
public "gradientFillV"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer): void
public "gradientFillV"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: integer, arg5: integer): void
public "shadedFill"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer, arg7: integer): void
public "shadedFill"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: integer, arg7: integer, arg8: integer): void
public "shadedFill"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
public "shadedFillInternal"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: integer, arg7: integer, arg8: integer, arg9: integer): void
public "batchDraw"(arg0: $Runnable$Type): void
public "overrideFont"(arg0: $Font$Type): void
public "tileSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: integer, arg7: integer, arg8: float, arg9: float, arg10: float, arg11: float): void
public "tileSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: integer, arg7: integer, arg8: integer): void
public "tileSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: integer): void
public "tileSprite"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: float, arg7: float, arg8: float, arg9: float): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: float, arg7: float, arg8: float, arg9: float): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: integer): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type, arg7: float, arg8: float, arg9: float, arg10: float): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: integer, arg3: $TextureAtlasSprite$Type, arg4: integer): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: $TextureAtlasSprite$Type): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: integer, arg3: $TextureAtlasSprite$Type, arg4: float, arg5: float, arg6: float, arg7: float): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer, arg6: $TextureAtlasSprite$Type, arg7: integer): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: integer, arg3: $TextureAtlasSprite$Type): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: $TextureAtlasSprite$Type, arg3: integer): void
public "spriteRect"(arg0: $RenderType$Type, arg1: $Rectangle$Type, arg2: $TextureAtlasSprite$Type, arg3: float, arg4: float, arg5: float, arg6: float): void
public "spriteRect"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type): void
public "partialSpriteTex"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: double, arg7: double, arg8: double, arg9: double, arg10: float, arg11: float, arg12: float, arg13: float): void
public "partialSpriteTex"(arg0: $RenderType$Type, arg1: double, arg2: double, arg3: double, arg4: double, arg5: $TextureAtlasSprite$Type, arg6: double, arg7: double, arg8: double, arg9: double, arg10: integer): void
public static "texType"(arg0: $ResourceLocation$Type): $RenderType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiRender$Type = ($GuiRender);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiRender_ = $GuiRender$Type;
}}
declare module "packages/codechicken/lib/data/$MCDataOutput" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$IForgeRegistry, $IForgeRegistry$Type} from "packages/net/minecraftforge/registries/$IForgeRegistry"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$Vector3f, $Vector3f$Type} from "packages/org/joml/$Vector3f"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$FluidStack, $FluidStack$Type} from "packages/net/minecraftforge/fluids/$FluidStack"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$CharBuffer, $CharBuffer$Type} from "packages/java/nio/$CharBuffer"
import {$FloatBuffer, $FloatBuffer$Type} from "packages/java/nio/$FloatBuffer"
import {$ByteBuf, $ByteBuf$Type} from "packages/io/netty/buffer/$ByteBuf"
import {$Cuboid6, $Cuboid6$Type} from "packages/codechicken/lib/vec/$Cuboid6"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$DoubleBuffer, $DoubleBuffer$Type} from "packages/java/nio/$DoubleBuffer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$OutputStream, $OutputStream$Type} from "packages/java/io/$OutputStream"
import {$ShortBuffer, $ShortBuffer$Type} from "packages/java/nio/$ShortBuffer"
import {$LongBuffer, $LongBuffer$Type} from "packages/java/nio/$LongBuffer"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$ByteBuffer, $ByteBuffer$Type} from "packages/java/nio/$ByteBuffer"
import {$DataOutput, $DataOutput$Type} from "packages/java/io/$DataOutput"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IntBuffer, $IntBuffer$Type} from "packages/java/nio/$IntBuffer"

export interface $MCDataOutput {

 "append"(arg0: (byte)[]): $MCDataOutput
 "append"(arg0: $ByteBuf$Type): $MCDataOutput
 "writeInt"(arg0: integer): $MCDataOutput
 "writeBytes"(arg0: (byte)[]): $MCDataOutput
 "writeBytes"(arg0: (byte)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeChar"(arg0: integer): $MCDataOutput
 "writeFloat"(arg0: float): $MCDataOutput
 "writeString"(arg0: string): $MCDataOutput
 "writeString"(arg0: string, arg1: integer): $MCDataOutput
 "writeLong"(arg0: long): $MCDataOutput
 "writeBoolean"(arg0: boolean): $MCDataOutput
 "writeByte"(arg0: integer): $MCDataOutput
 "writeShort"(arg0: integer): $MCDataOutput
 "writeDouble"(arg0: double): $MCDataOutput
 "writeChars"(arg0: (character)[]): $MCDataOutput
 "writeChars"(arg0: (character)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeItemStack"(arg0: $ItemStack$Type): $MCDataOutput
 "writeItemStack"(arg0: $ItemStack$Type, arg1: boolean): $MCDataOutput
 "writeRegistryId"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $MCDataOutput
 "writeRegistryId"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: T): $MCDataOutput
 "writeFluidStack"(arg0: $FluidStack$Type): $MCDataOutput
 "writeShorts"(arg0: (short)[]): $MCDataOutput
 "writeShorts"(arg0: (short)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeInts"(arg0: (integer)[]): $MCDataOutput
 "writeInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeLongs"(arg0: (long)[]): $MCDataOutput
 "writeLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeFloats"(arg0: (float)[]): $MCDataOutput
 "writeFloats"(arg0: (float)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeDoubles"(arg0: (double)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeDoubles"(arg0: (double)[]): $MCDataOutput
 "writeSignedVarInt"(arg0: integer): $MCDataOutput
 "writeCharBuffer"(arg0: $CharBuffer$Type): $MCDataOutput
 "writeVarLong"(arg0: long): $MCDataOutput
 "writeUUID"(arg0: $UUID$Type): $MCDataOutput
 "writeShortBuffer"(arg0: $ShortBuffer$Type): $MCDataOutput
 "writeSignedVarInts"(arg0: (integer)[]): $MCDataOutput
 "writeSignedVarInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeByteBuffer"(arg0: $ByteBuffer$Type): $MCDataOutput
 "writeLongBuffer"(arg0: $LongBuffer$Type): $MCDataOutput
 "writeFloatBuffer"(arg0: $FloatBuffer$Type): $MCDataOutput
 "writeVarInts"(arg0: (integer)[]): $MCDataOutput
 "writeVarInts"(arg0: (integer)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeDoubleBuffer"(arg0: $DoubleBuffer$Type): $MCDataOutput
 "writeVarLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeVarLongs"(arg0: (long)[]): $MCDataOutput
 "writeIntBuffer"(arg0: $IntBuffer$Type): $MCDataOutput
 "writeSignedVarLong"(arg0: long): $MCDataOutput
 "writeCuboid"(arg0: $Cuboid6$Type): $MCDataOutput
 "writeCompoundNBT"(arg0: $CompoundTag$Type): $MCDataOutput
 "writeVec3d"(arg0: $Vec3$Type): $MCDataOutput
 "writeVec3f"(arg0: $Vector3f$Type): $MCDataOutput
 "writeTextComponent"(arg0: $Component$Type): $MCDataOutput
 "toDataOutput"(): $DataOutput
 "writeVec3i"(arg0: $Vec3i$Type): $MCDataOutput
 "writeDirection"(arg0: $Direction$Type): $MCDataOutput
 "writeByteBuf"(arg0: $ByteBuf$Type): $MCDataOutput
 "writeVector"(arg0: $Vector3$Type): $MCDataOutput
 "toOutputStream"(): $OutputStream
 "writeBooleans"(arg0: (boolean)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeBooleans"(arg0: (boolean)[]): $MCDataOutput
 "writePos"(arg0: $BlockPos$Type): $MCDataOutput
 "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: T): $MCDataOutput
 "writeRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>, arg1: $ResourceLocation$Type): $MCDataOutput
 "writeResourceLocation"(arg0: $ResourceLocation$Type): $MCDataOutput
 "writeSignedVarLongs"(arg0: (long)[], arg1: integer, arg2: integer): $MCDataOutput
 "writeSignedVarLongs"(arg0: (long)[]): $MCDataOutput
 "writeEnum"(arg0: $Enum$Type<(any)>): $MCDataOutput
 "writeVarInt"(arg0: integer): $MCDataOutput
}

export namespace $MCDataOutput {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MCDataOutput$Type = ($MCDataOutput);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MCDataOutput_ = $MCDataOutput$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Mutable" {
import {$Position, $Position$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position"
import {$Position$Mutable, $Position$Mutable$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Position$Mutable"
import {$Rectangle, $Rectangle$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle"
import {$GuiParent, $GuiParent$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GuiParent"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$Rectangle$Immutable, $Rectangle$Immutable$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Rectangle$Immutable"
import {$Axis, $Axis$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$Axis"
import {$Rect2i, $Rect2i$Type} from "packages/net/minecraft/client/renderer/$Rect2i"

export class $Rectangle$Mutable implements $Rectangle {

constructor(arg0: $Position$Mutable$Type, arg1: double, arg2: double)

public "set"(arg0: $Rectangle$Type): void
public "combine"(...arg0: ($Rectangle$Type)[]): $Rectangle
public "pos"(): $Position
public "offsetSize"(arg0: double, arg1: double): $Rectangle
public "setSize"(arg0: double, arg1: double): $Rectangle
public "width"(): double
public "height"(): double
public "immutable"(): $Rectangle$Immutable
public "intersect"(arg0: $Rectangle$Type): $Rectangle
public "setPos"(arg0: double, arg1: double): $Rectangle
public "offsetPos"(arg0: double, arg1: double): $Rectangle
public "min"(arg0: $Axis$Type): double
public "max"(arg0: $Axis$Type): double
public "size"(arg0: $Axis$Type): double
public "x"(): double
public "contains"(arg0: double, arg1: double): boolean
public static "create"(arg0: $Position$Type, arg1: double, arg2: double): $Rectangle
public static "create"(arg0: $Position$Type, arg1: $Supplier$Type<(double)>, arg2: $Supplier$Type<(double)>): $Rectangle
public static "create"(arg0: double, arg1: double, arg2: double, arg3: double): $Rectangle
public static "create"(arg0: $GuiParent$Type<(any)>): $Rectangle
public "y"(): double
public "distance"(arg0: $Axis$Type, arg1: $Position$Type): double
public "mutable"(): $Rectangle$Mutable
public "intersects"(arg0: double, arg1: double, arg2: double, arg3: double): boolean
public "intersects"(arg0: $Rectangle$Type): boolean
public "yMax"(): double
public "xMax"(): double
public "toRect2i"(): $Rect2i
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Rectangle$Mutable$Type = ($Rectangle$Mutable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Rectangle$Mutable_ = $Rectangle$Mutable$Type;
}}
declare module "packages/codechicken/lib/inventory/container/modular/$ModularGuiContainerMenu" {
import {$NonNullList, $NonNullList$Type} from "packages/net/minecraft/core/$NonNullList"
import {$SlotGroup, $SlotGroup$Type} from "packages/codechicken/lib/gui/modular/lib/container/$SlotGroup"
import {$DataSync, $DataSync$Type} from "packages/codechicken/lib/gui/modular/lib/container/$DataSync"
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$Slot, $Slot$Type} from "packages/net/minecraft/world/inventory/$Slot"
import {$ContainerListener, $ContainerListener$Type} from "packages/net/minecraft/world/inventory/$ContainerListener"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$List, $List$Type} from "packages/java/util/$List"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$MCDataOutput, $MCDataOutput$Type} from "packages/codechicken/lib/data/$MCDataOutput"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ModularGuiContainerMenu extends $AbstractContainerMenu {
readonly "inventory": $Inventory
readonly "slotGroups": $List<($SlotGroup)>
readonly "slotGroupMap": $Map<($Slot), ($SlotGroup)>
readonly "zonedSlots": $Map<(integer), ($List<($Slot)>)>
readonly "dataSyncs": $List<($DataSync<(any)>)>
static readonly "SLOT_CLICKED_OUTSIDE": integer
static readonly "QUICKCRAFT_TYPE_CHARITABLE": integer
static readonly "QUICKCRAFT_TYPE_GREEDY": integer
static readonly "QUICKCRAFT_TYPE_CLONE": integer
static readonly "QUICKCRAFT_HEADER_START": integer
static readonly "QUICKCRAFT_HEADER_CONTINUE": integer
static readonly "QUICKCRAFT_HEADER_END": integer
static readonly "CARRIED_SLOT_SIZE": integer
 "lastSlots": $NonNullList<($ItemStack)>
readonly "slots": $NonNullList<($Slot)>
 "carried": $ItemStack
 "remoteSlots": $NonNullList<($ItemStack)>
 "stateId": integer
 "containerId": integer
 "quickcraftType": integer
 "quickcraftStatus": integer
readonly "quickcraftSlots": $Set<($Slot)>
readonly "containerListeners": $List<($ContainerListener)>


public "quickMoveStack"(arg0: $Player$Type, arg1: integer): $ItemStack
public "broadcastChanges"(): void
public static "canStacksMerge"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): boolean
public static "handlePacketFromServer"(arg0: $Player$Type, arg1: $MCDataInput$Type): void
public "handlePacketFromServer"(arg0: $Player$Type, arg1: integer, arg2: $MCDataInput$Type): void
public static "handlePacketFromClient"(arg0: $Player$Type, arg1: $MCDataInput$Type): void
public "handlePacketFromClient"(arg0: $Player$Type, arg1: integer, arg2: $MCDataInput$Type): void
public "sendPacketToClient"(arg0: integer, arg1: $Consumer$Type<($MCDataOutput$Type)>): void
public "sendPacketToServer"(arg0: integer, arg1: $Consumer$Type<($MCDataOutput$Type)>): void
public "mapSlot"(arg0: $Slot$Type, arg1: $SlotGroup$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularGuiContainerMenu$Type = ($ModularGuiContainerMenu);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularGuiContainerMenu_ = $ModularGuiContainerMenu$Type;
}}
declare module "packages/codechicken/lib/util/$Copyable" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $Copyable<T> {

 "copy"(): T

(): T
}

export namespace $Copyable {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Copyable$Type<T> = ($Copyable<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Copyable_<T> = $Copyable$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$Dynamic extends $ConstraintImpl<($ConstraintImpl$Dynamic)> {

constructor(arg0: $Supplier$Type<(double)>)

public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$Dynamic$Type = ($ConstraintImpl$Dynamic);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$Dynamic_ = $ConstraintImpl$Dynamic$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/$GuiProvider" {
import {$GuiElement, $GuiElement$Type} from "packages/codechicken/lib/gui/modular/elements/$GuiElement"
import {$ModularGui, $ModularGui$Type} from "packages/codechicken/lib/gui/modular/$ModularGui"

export interface $GuiProvider {

 "buildGui"(arg0: $ModularGui$Type): void
 "createRootElement"(arg0: $ModularGui$Type): $GuiElement<(any)>

(arg0: $ModularGui$Type): void
}

export namespace $GuiProvider {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiProvider$Type = ($GuiProvider);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiProvider_ = $GuiProvider$Type;
}}
declare module "packages/codechicken/lib/inventory/container/$ICCLContainerType" {
import {$MCDataInput, $MCDataInput$Type} from "packages/codechicken/lib/data/$MCDataInput"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$ICCLContainerFactory, $ICCLContainerFactory$Type} from "packages/codechicken/lib/inventory/container/$ICCLContainerFactory"
import {$FeatureFlag, $FeatureFlag$Type} from "packages/net/minecraft/world/flag/$FeatureFlag"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"

export interface $ICCLContainerType<T extends $AbstractContainerMenu> {

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

(arg0: $ICCLContainerFactory$Type<(T)>): $MenuType<(T)>
}

export namespace $ICCLContainerType {
function create<T>(arg0: $ICCLContainerFactory$Type<(T)>): $MenuType<(T)>
function create<T>(arg0: $ICCLContainerFactory$Type<(T)>, ...arg1: ($FeatureFlag$Type)[]): $MenuType<(T)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICCLContainerType$Type<T> = ($ICCLContainerType<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICCLContainerType_<T> = $ICCLContainerType$Type<(T)>;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$BetweenOffset extends $ConstraintImpl$Between {

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

public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$BetweenOffset$Type = ($ConstraintImpl$BetweenOffset);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$BetweenOffset_ = $ConstraintImpl$BetweenOffset$Type;
}}
declare module "packages/codechicken/lib/data/$MCDataInput" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$DataInput, $DataInput$Type} from "packages/java/io/$DataInput"
import {$IForgeRegistry, $IForgeRegistry$Type} from "packages/net/minecraftforge/registries/$IForgeRegistry"
import {$Vector3f, $Vector3f$Type} from "packages/org/joml/$Vector3f"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$FluidStack, $FluidStack$Type} from "packages/net/minecraftforge/fluids/$FluidStack"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$CharBuffer, $CharBuffer$Type} from "packages/java/nio/$CharBuffer"
import {$MutableComponent, $MutableComponent$Type} from "packages/net/minecraft/network/chat/$MutableComponent"
import {$FloatBuffer, $FloatBuffer$Type} from "packages/java/nio/$FloatBuffer"
import {$ByteBuf, $ByteBuf$Type} from "packages/io/netty/buffer/$ByteBuf"
import {$InputStream, $InputStream$Type} from "packages/java/io/$InputStream"
import {$Cuboid6, $Cuboid6$Type} from "packages/codechicken/lib/vec/$Cuboid6"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$DoubleBuffer, $DoubleBuffer$Type} from "packages/java/nio/$DoubleBuffer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ShortBuffer, $ShortBuffer$Type} from "packages/java/nio/$ShortBuffer"
import {$Class, $Class$Type} from "packages/java/lang/$Class"
import {$LongBuffer, $LongBuffer$Type} from "packages/java/nio/$LongBuffer"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$ByteBuffer, $ByteBuffer$Type} from "packages/java/nio/$ByteBuffer"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IntBuffer, $IntBuffer$Type} from "packages/java/nio/$IntBuffer"

export interface $MCDataInput {

 "readInt"(): integer
 "readBytes"(): (byte)[]
 "readChar"(): character
 "toInputStream"(): $InputStream
 "readFloat"(): float
 "readLong"(): long
 "readByte"(): byte
 "readShort"(): short
 "readString"(): string
 "readBoolean"(): boolean
 "readDouble"(): double
 "readEnum"<T extends $Enum<(T)>>(arg0: $Class$Type<(T)>): T
 "readInts"(): (integer)[]
 "readLongs"(): (long)[]
 "readFloats"(): (float)[]
 "readDoubles"(): (double)[]
 "readShorts"(): (short)[]
 "readChars"(): (character)[]
 "readBooleans"(): (boolean)[]
 "readRegistryId"<T>(): T
 "readFluidStack"(): $FluidStack
 "readPos"(): $BlockPos
 "readRegistryIdDirect"<T>(arg0: $IForgeRegistry$Type<(T)>): T
 "readResourceLocation"(): $ResourceLocation
 "readItemStack"(): $ItemStack
 "readVarInt"(): integer
 "readVector"(): $Vector3
 "readUUID"(): $UUID
 "readSignedVarInts"(): (integer)[]
 "readSignedVarInt"(): integer
 "readShortBuffer"(): $ShortBuffer
 "readByteBuffer"(): $ByteBuffer
 "readIntBuffer"(): $IntBuffer
 "readCharBuffer"(): $CharBuffer
 "readVarInts"(): (integer)[]
 "readVarLongs"(): (long)[]
 "readUShort"(): integer
 "readLongBuffer"(): $LongBuffer
 "readVarLong"(): long
 "readSignedVarLongs"(): (long)[]
 "readFloatBuffer"(): $FloatBuffer
 "readTextComponent"(): $MutableComponent
 "readSignedVarLong"(): long
 "readUByte"(): short
 "readCompoundNBT"(): $CompoundTag
 "readVec3i"(): $Vec3i
 "readVec3f"(): $Vector3f
 "readDoubleBuffer"(): $DoubleBuffer
 "readCuboid"(): $Cuboid6
 "readByteBuf"(): $ByteBuf
 "toDataInput"(): $DataInput
 "readVec3d"(): $Vec3
 "readDirection"(): $Direction
}

export namespace $MCDataInput {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MCDataInput$Type = ($MCDataInput);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MCDataInput_ = $MCDataInput$Type;
}}
declare module "packages/codechicken/lib/vec/$Vector3" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Vector4f, $Vector4f$Type} from "packages/org/joml/$Vector4f"
import {$Vector3f, $Vector3f$Type} from "packages/org/joml/$Vector3f"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$Quat, $Quat$Type} from "packages/codechicken/lib/vec/$Quat"
import {$Translation, $Translation$Type} from "packages/codechicken/lib/vec/$Translation"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"
import {$Entity, $Entity$Type} from "packages/net/minecraft/world/entity/$Entity"

export class $Vector3 implements $Copyable<($Vector3)> {
static readonly "ZERO": $Vector3
static readonly "CENTER": $Vector3
static readonly "ONE": $Vector3
static readonly "X_POS": $Vector3
static readonly "X_NEG": $Vector3
static readonly "Y_POS": $Vector3
static readonly "Y_NEG": $Vector3
static readonly "Z_POS": $Vector3
static readonly "Z_NEG": $Vector3
 "x": double
 "y": double
 "z": double

constructor(arg0: $Vec3$Type)
constructor(arg0: (float)[])
constructor(arg0: (double)[])
constructor()
constructor(arg0: double, arg1: double, arg2: double)
constructor(arg0: $Vector3$Type)

public "add"(arg0: double): $Vector3
public "add"(arg0: double, arg1: double, arg2: double): $Vector3
public "add"(arg0: $Vector3$Type): $Vector3
public "add"(arg0: $Vec3$Type): $Vector3
public "add"(arg0: $BlockPos$Type): $Vector3
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "floor"(): $Vector3
public "ceil"(): $Vector3
public "apply"(arg0: $Transformation$Type): $Vector3
public "set"(arg0: $Vector3$Type): $Vector3
public "set"(arg0: (float)[]): $Vector3
public "set"(arg0: (double)[]): $Vector3
public "set"(arg0: double, arg1: double, arg2: double): $Vector3
public "set"(arg0: $Vec3i$Type): $Vector3
public "set"(arg0: double): $Vector3
public "copy"(): $Vector3
public "pos"(): $BlockPos
public "normalize"(): $Vector3
public "mag"(): double
public "distance"(arg0: $Vector3$Type): double
public "rotate"(arg0: double, arg1: $Vector3$Type): $Vector3
public "rotate"(arg0: $Quat$Type): $Vector3
public "negate"(): $Vector3
public "isZero"(): boolean
public "divide"(arg0: double): $Vector3
public "divide"(arg0: double, arg1: double, arg2: double): $Vector3
public "divide"(arg0: $BlockPos$Type): $Vector3
public "divide"(arg0: $Vector3$Type): $Vector3
public "subtract"(arg0: double, arg1: double, arg2: double): $Vector3
public "subtract"(arg0: double): $Vector3
public "subtract"(arg0: $BlockPos$Type): $Vector3
public "subtract"(arg0: $Vec3$Type): $Vector3
public "subtract"(arg0: $Vector3$Type): $Vector3
public "getSide"(arg0: integer): double
public "setSide"(arg0: integer, arg1: double): $Vector3
public "perpendicular"(): $Vector3
public "vec3"(): $Vec3
public "project"(arg0: $Vector3$Type): $Vector3
public "translation"(): $Translation
public "angle"(arg0: $Vector3$Type): double
public "distanceSquared"(arg0: $Vector3$Type): double
public "writeToNBT"(arg0: $CompoundTag$Type): $CompoundTag
public "crossProduct"(arg0: $Vector3$Type): $Vector3
public "vector4f"(): $Vector4f
public "vector3f"(): $Vector3f
public static "fromBlockPos"(arg0: $BlockPos$Type): $Vector3
public static "fromTile"(arg0: $BlockEntity$Type): $Vector3
public static "fromArray"(arg0: (float)[]): $Vector3
public static "fromArray"(arg0: (double)[]): $Vector3
public static "fromEntity"(arg0: $Entity$Type): $Vector3
public static "fromTileCenter"(arg0: $BlockEntity$Type): $Vector3
public "magSquared"(): double
public "toArrayF"(): (float)[]
public static "fromAxes"(arg0: (float)[]): $Vector3
public static "fromAxes"(arg0: (double)[]): $Vector3
public "zCrossProduct"(): $Vector3
public "xCrossProduct"(): $Vector3
public static "fromEntityCenter"(arg0: $Entity$Type): $Vector3
public "yCrossProduct"(): $Vector3
public static "fromBlockPosCenter"(arg0: $BlockPos$Type): $Vector3
public "toArrayD"(): (double)[]
public "dotProduct"(arg0: $Vector3$Type): double
public "dotProduct"(arg0: double, arg1: double, arg2: double): double
public "$tilde"(): $Vector3
public "$div"(arg0: double): $Vector3
public "XZintercept"(arg0: $Vector3$Type, arg1: double): $Vector3
public "$plus"(arg0: $Vector3$Type): $Vector3
public "$minus"(arg0: $Vector3$Type): $Vector3
public "isAxial"(): boolean
public "$dot$times"(arg0: $Vector3$Type): double
public "scalarProject"(arg0: $Vector3$Type): double
public "YZintercept"(arg0: $Vector3$Type, arg1: double): $Vector3
public "$times"(arg0: $Vector3$Type): $Vector3
public "$times"(arg0: double): $Vector3
public "unary_$tilde"(): $Vector3
public "XYintercept"(arg0: $Vector3$Type, arg1: double): $Vector3
public static "fromNBT"(arg0: $CompoundTag$Type): $Vector3
public static "fromVec3i"(arg0: $Vec3i$Type): $Vector3
public "equalsT"(arg0: $Vector3$Type): boolean
public "multiply"(arg0: double, arg1: double, arg2: double): $Vector3
public "multiply"(arg0: $Vector3$Type): $Vector3
public "multiply"(arg0: double): $Vector3
get "zero"(): boolean
get "axial"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Vector3$Type = ($Vector3);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Vector3_ = $Vector3$Type;
}}
declare module "packages/codechicken/lib/vec/$Matrix4" {
import {$FloatBuffer, $FloatBuffer$Type} from "packages/java/nio/$FloatBuffer"
import {$DoubleBuffer, $DoubleBuffer$Type} from "packages/java/nio/$DoubleBuffer"
import {$Rotation, $Rotation$Type} from "packages/codechicken/lib/vec/$Rotation"
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Vector4f, $Vector4f$Type} from "packages/org/joml/$Vector4f"
import {$PoseStack, $PoseStack$Type} from "packages/com/mojang/blaze3d/vertex/$PoseStack"
import {$Vec3i, $Vec3i$Type} from "packages/net/minecraft/core/$Vec3i"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$IntBuffer, $IntBuffer$Type} from "packages/java/nio/$IntBuffer"
import {$Matrix4f, $Matrix4f$Type} from "packages/org/joml/$Matrix4f"

export class $Matrix4 extends $Transformation {
 "m00": double
 "m01": double
 "m02": double
 "m03": double
 "m10": double
 "m11": double
 "m12": double
 "m13": double
 "m20": double
 "m21": double
 "m22": double
 "m23": double
 "m30": double
 "m31": double
 "m32": double
 "m33": double
static readonly "operationIndex": integer

constructor(arg0: (double)[])
constructor(arg0: $FloatBuffer$Type)
constructor(arg0: $DoubleBuffer$Type)
constructor(arg0: $Matrix4f$Type)
constructor(arg0: $PoseStack$Type)
constructor()
constructor(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: double, arg6: double, arg7: double, arg8: double, arg9: double, arg10: double, arg11: double, arg12: double, arg13: double, arg14: double, arg15: double)
constructor(arg0: $Matrix4$Type)
constructor(arg0: (float)[])

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "scale"(arg0: double, arg1: double, arg2: double): $Matrix4
public "scale"(arg0: $Vector3$Type): $Matrix4
public "scale"(arg0: double): $Matrix4
public "apply"(arg0: $Vector3$Type): void
public "apply"(arg0: $Matrix4$Type): void
public "apply"(arg0: $Transformation$Type): $Matrix4
public "set"(arg0: (double)[]): $Matrix4
public "set"(arg0: $FloatBuffer$Type): $Matrix4
public "set"(arg0: (float)[]): $Matrix4
public "set"(arg0: $DoubleBuffer$Type): $Matrix4
public "set"(arg0: $PoseStack$Type): $Matrix4
public "set"(arg0: $Matrix4f$Type): $Matrix4
public "set"(arg0: $Matrix4$Type): $Matrix4
public "save"(arg0: $FloatBuffer$Type): void
public "save"(arg0: $DoubleBuffer$Type): void
public "rotate"(arg0: double, arg1: $Vector3$Type): $Matrix4
public "rotate"(arg0: $Rotation$Type): $Matrix4
public "transpose"(): $Matrix4
public "translate"(arg0: double, arg1: double, arg2: double): $Matrix4
public "translate"(arg0: $Vector3$Type): $Matrix4
public "translate"(arg0: $Vec3i$Type): $Matrix4
public static "gluProject"(arg0: $Vector3$Type, arg1: $Matrix4$Type, arg2: $Matrix4$Type, arg3: $IntBuffer$Type): $Vector3
public "multMatrix"(arg0: $Vector4f$Type): void
public "setIdentity"(): $Matrix4
public "applyN"(arg0: $Vector3$Type): void
public "toDoubleBuffer"(): $DoubleBuffer
public "toMatrix4f"(): $Matrix4f
public "toFloatBuffer"(): $FloatBuffer
public "leftMultiply"(arg0: $Matrix4$Type): $Matrix4
public "toArrayF"(): (float)[]
public "toArrayD"(): (double)[]
public "multiply"(arg0: $Matrix4$Type): $Matrix4
public static "registerOperation"(): integer
public static "operationCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Matrix4$Type = ($Matrix4);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Matrix4_ = $Matrix4$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between" {
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$MidPoint, $ConstraintImpl$MidPoint$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$Between extends $ConstraintImpl<($ConstraintImpl$Between)> {

constructor(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double)

public "getStart"(): double
public "clamp"(): $ConstraintImpl$Between
public "getPos"(): double
public "getEnd"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "start"(): double
get "pos"(): double
get "end"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$Between$Type = ($ConstraintImpl$Between);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$Between_ = $ConstraintImpl$Between$Type;
}}
declare module "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPoint" {
import {$ConstraintImpl$Between, $ConstraintImpl$Between$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Between"
import {$ConstraintImpl$MidPointDynamic, $ConstraintImpl$MidPointDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$MidPointDynamic"
import {$ConstraintImpl$BetweenOffset, $ConstraintImpl$BetweenOffset$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenOffset"
import {$ConstraintImpl$Relative, $ConstraintImpl$Relative$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Relative"
import {$ConstraintImpl$Literal, $ConstraintImpl$Literal$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Literal"
import {$ConstraintImpl$Dynamic, $ConstraintImpl$Dynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$Dynamic"
import {$ConstraintImpl, $ConstraintImpl$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl"
import {$GeoRef, $GeoRef$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$GeoRef"
import {$ConstraintImpl$BetweenDynamic, $ConstraintImpl$BetweenDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$BetweenDynamic"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ConstraintImpl$RelativeDynamic, $ConstraintImpl$RelativeDynamic$Type} from "packages/codechicken/lib/gui/modular/lib/geometry/$ConstraintImpl$RelativeDynamic"

export class $ConstraintImpl$MidPoint extends $ConstraintImpl<($ConstraintImpl$MidPoint)> {

constructor(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double)

public "getOffset"(): double
public "getStart"(): double
public "getEnd"(): double
public static "match"(arg0: $GeoRef$Type): $ConstraintImpl$Relative
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$Between
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double, arg3: double): $ConstraintImpl$BetweenOffset
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>, arg3: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "between"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$BetweenDynamic
public static "literal"(arg0: double): $ConstraintImpl$Literal
public static "relative"(arg0: $GeoRef$Type, arg1: $Supplier$Type<(double)>): $ConstraintImpl$RelativeDynamic
public static "relative"(arg0: $GeoRef$Type, arg1: double): $ConstraintImpl$Relative
public static "dynamic"(arg0: $Supplier$Type<(double)>): $ConstraintImpl$Dynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: $Supplier$Type<(double)>): $ConstraintImpl$MidPointDynamic
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type): $ConstraintImpl$MidPoint
public static "midPoint"(arg0: $GeoRef$Type, arg1: $GeoRef$Type, arg2: double): $ConstraintImpl$MidPoint
get "offset"(): double
get "start"(): double
get "end"(): double
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ConstraintImpl$MidPoint$Type = ($ConstraintImpl$MidPoint);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ConstraintImpl$MidPoint_ = $ConstraintImpl$MidPoint$Type;
}}
declare module "packages/codechicken/lib/vec/$Vertex5" {
import {$UVTransformation, $UVTransformation$Type} from "packages/codechicken/lib/vec/uv/$UVTransformation"
import {$Transformation, $Transformation$Type} from "packages/codechicken/lib/vec/$Transformation"
import {$Vector3, $Vector3$Type} from "packages/codechicken/lib/vec/$Vector3"
import {$UV, $UV$Type} from "packages/codechicken/lib/vec/uv/$UV"
import {$Copyable, $Copyable$Type} from "packages/codechicken/lib/util/$Copyable"

export class $Vertex5 implements $Copyable<($Vertex5)> {
 "vec": $Vector3
 "uv": $UV

constructor(arg0: $Vertex5$Type)
constructor(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer)
constructor(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double)
constructor()
constructor(arg0: $Vector3$Type, arg1: $UV$Type)
constructor(arg0: $Vector3$Type, arg1: double, arg2: double)

public "toString"(): string
public "apply"(arg0: $Transformation$Type): $Vertex5
public "apply"(arg0: $UVTransformation$Type): $Vertex5
public "set"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double): $Vertex5
public "set"(arg0: double, arg1: double, arg2: double, arg3: double, arg4: double, arg5: integer): $Vertex5
public "set"(arg0: $Vector3$Type, arg1: double, arg2: double): $Vertex5
public "set"(arg0: $Vertex5$Type): $Vertex5
public "copy"(): $Vertex5
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Vertex5$Type = ($Vertex5);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Vertex5_ = $Vertex5$Type;
}}
declare module "packages/codechicken/lib/vec/uv/$UVTransformation" {
import {$UVTransformationList, $UVTransformationList$Type} from "packages/codechicken/lib/vec/uv/$UVTransformationList"
import {$ITransformation, $ITransformation$Type} from "packages/codechicken/lib/vec/$ITransformation"
import {$CCRenderState, $CCRenderState$Type} from "packages/codechicken/lib/render/$CCRenderState"
import {$UV, $UV$Type} from "packages/codechicken/lib/vec/uv/$UV"
import {$IVertexOperation, $IVertexOperation$Type} from "packages/codechicken/lib/render/pipeline/$IVertexOperation"

export class $UVTransformation extends $ITransformation<($UV), ($UVTransformation)> implements $IVertexOperation {
static readonly "operationIndex": integer

constructor()

public "load"(arg0: $CCRenderState$Type): boolean
public "at"(arg0: $UV$Type): $UVTransformation
public "with"(arg0: $UVTransformation$Type): $UVTransformationList
public "operationID"(): integer
public "operate"(arg0: $CCRenderState$Type): void
public static "registerOperation"(): integer
public static "operationCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UVTransformation$Type = ($UVTransformation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UVTransformation_ = $UVTransformation$Type;
}}
declare module "packages/codechicken/lib/colour/$EnumColour" {
import {$StringRepresentable$EnumCodec, $StringRepresentable$EnumCodec$Type} from "packages/net/minecraft/util/$StringRepresentable$EnumCodec"
import {$StringRepresentable, $StringRepresentable$Type} from "packages/net/minecraft/util/$StringRepresentable"
import {$Function, $Function$Type} from "packages/java/util/function/$Function"
import {$Keyable, $Keyable$Type} from "packages/com/mojang/serialization/$Keyable"
import {$ColourRGBA, $ColourRGBA$Type} from "packages/codechicken/lib/colour/$ColourRGBA"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"

export class $EnumColour extends $Enum<($EnumColour)> implements $StringRepresentable {
static readonly "WHITE": $EnumColour
static readonly "ORANGE": $EnumColour
static readonly "MAGENTA": $EnumColour
static readonly "LIGHT_BLUE": $EnumColour
static readonly "YELLOW": $EnumColour
static readonly "LIME": $EnumColour
static readonly "PINK": $EnumColour
static readonly "GRAY": $EnumColour
static readonly "LIGHT_GRAY": $EnumColour
static readonly "CYAN": $EnumColour
static readonly "PURPLE": $EnumColour
static readonly "BLUE": $EnumColour
static readonly "BROWN": $EnumColour
static readonly "GREEN": $EnumColour
static readonly "RED": $EnumColour
static readonly "BLACK": $EnumColour


public static "values"(): ($EnumColour)[]
public static "valueOf"(arg0: string): $EnumColour
public static "mix"(arg0: $EnumColour$Type, arg1: $EnumColour$Type): $EnumColour
public "mix"(arg0: $EnumColour$Type): $EnumColour
public "bF"(): float
public "getLocalizedName"(): string
public "gF"(): float
public "getUnlocalizedName"(): string
public "getSerializedName"(): string
public "rF"(): float
public "rgb"(): integer
public "argb"(): integer
public "argb"(arg0: integer): integer
public "getDyeMeta"(): integer
public "getWoolMeta"(): integer
public static "fromDyeStack"(arg0: $ItemStack$Type): $EnumColour
public static "fromWoolMeta"(arg0: integer): $EnumColour
public static "fromWoolTag"(arg0: $ResourceLocation$Type): $EnumColour
public static "fromWoolStack"(arg0: $ItemStack$Type): $EnumColour
public static "fromName"(arg0: string): $EnumColour
public "getWoolTagName"(): $ResourceLocation
public static "fromDyeTag"(arg0: $ResourceLocation$Type): $EnumColour
public "getDyeTagName"(): $ResourceLocation
public static "fromDyeMeta"(arg0: integer): $EnumColour
public "rgba"(arg0: integer): integer
public "rgba"(): integer
public "getColour"(): $ColourRGBA
public "getColour"(arg0: integer): $ColourRGBA
public static "fromEnum"<E extends ($Enum<(E)>) & ($StringRepresentable)>(arg0: $Supplier$Type<((E)[])>): $StringRepresentable$EnumCodec<(E)>
public static "fromEnumWithMapping"<E extends ($Enum<(E)>) & ($StringRepresentable)>(arg0: $Supplier$Type<((E)[])>, arg1: $Function$Type<(string), (string)>): $StringRepresentable$EnumCodec<(E)>
public static "keys"(arg0: ($StringRepresentable$Type)[]): $Keyable
get "localizedName"(): string
get "unlocalizedName"(): string
get "serializedName"(): string
get "dyeMeta"(): integer
get "woolMeta"(): integer
get "woolTagName"(): $ResourceLocation
get "dyeTagName"(): $ResourceLocation
get "colour"(): $ColourRGBA
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnumColour$Type = (("magenta") | ("pink") | ("green") | ("lime") | ("light_gray") | ("yellow") | ("black") | ("light_blue") | ("brown") | ("cyan") | ("orange") | ("red") | ("gray") | ("white") | ("blue") | ("purple")) | ($EnumColour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnumColour_ = $EnumColour$Type;
}}
