declare module "packages/me/desht/modularrouters/item/upgrade/$MufflerUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $MufflerUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MufflerUpgrade$Type = ($MufflerUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MufflerUpgrade_ = $MufflerUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$CamouflageUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UseOnContext, $UseOnContext$Type} from "packages/net/minecraft/world/item/context/$UseOnContext"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $CamouflageUpgrade extends $UpgradeItem {
static readonly "NBT_STATE_NAME": string
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "useOn"(arg0: $UseOnContext$Type): $InteractionResult
public "getName"(arg0: $ItemStack$Type): $Component
public "onCompiled"(arg0: $ItemStack$Type, arg1: $ModularRouterBlockEntity$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CamouflageUpgrade$Type = ($CamouflageUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CamouflageUpgrade_ = $CamouflageUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity$TrackedEnergy" {
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$ContainerData, $ContainerData$Type} from "packages/net/minecraft/world/inventory/$ContainerData"

export class $ModularRouterBlockEntity$TrackedEnergy implements $ContainerData {

constructor(arg0: $ModularRouterBlockEntity$Type)

public "getCount"(): integer
public "set"(arg0: integer, arg1: integer): void
public "get"(arg0: integer): integer
get "count"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularRouterBlockEntity$TrackedEnergy$Type = ($ModularRouterBlockEntity$TrackedEnergy);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularRouterBlockEntity$TrackedEnergy_ = $ModularRouterBlockEntity$TrackedEnergy$Type;
}}
declare module "packages/me/desht/modularrouters/block/$TemplateFrameBlock" {
import {$EntityBlock, $EntityBlock$Type} from "packages/net/minecraft/world/level/block/$EntityBlock"
import {$CamouflageableBlock, $CamouflageableBlock$Type} from "packages/me/desht/modularrouters/block/$CamouflageableBlock"
import {$VoxelShape, $VoxelShape$Type} from "packages/net/minecraft/world/phys/shapes/$VoxelShape"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
import {$CollisionContext, $CollisionContext$Type} from "packages/net/minecraft/world/phys/shapes/$CollisionContext"
import {$BlockState, $BlockState$Type} from "packages/net/minecraft/world/level/block/state/$BlockState"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$BlockEntityType, $BlockEntityType$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntityType"
import {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$BlockGetter, $BlockGetter$Type} from "packages/net/minecraft/world/level/$BlockGetter"
import {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$HitResult, $HitResult$Type} from "packages/net/minecraft/world/phys/$HitResult"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$ServerLevel, $ServerLevel$Type} from "packages/net/minecraft/server/level/$ServerLevel"
import {$BlockEntityTicker, $BlockEntityTicker$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntityTicker"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$GameEventListener, $GameEventListener$Type} from "packages/net/minecraft/world/level/gameevent/$GameEventListener"
import {$ModelProperty, $ModelProperty$Type} from "packages/net/minecraftforge/client/model/data/$ModelProperty"

export class $TemplateFrameBlock extends $CamouflageableBlock implements $EntityBlock {
static readonly "CAMOUFLAGE_STATE": $ModelProperty<($BlockState)>
/**
 * 
 * @deprecated
 */
static readonly "BLOCK_STATE_REGISTRY": $IdMapper<($BlockState)>
static readonly "UPDATE_NEIGHBORS": integer
static readonly "UPDATE_CLIENTS": integer
static readonly "UPDATE_INVISIBLE": integer
static readonly "UPDATE_IMMEDIATE": integer
static readonly "UPDATE_KNOWN_SHAPE": integer
static readonly "UPDATE_SUPPRESS_DROPS": integer
static readonly "UPDATE_MOVE_BY_PISTON": integer
static readonly "UPDATE_NONE": integer
static readonly "UPDATE_ALL": integer
static readonly "UPDATE_ALL_IMMEDIATE": integer
static readonly "INDESTRUCTIBLE": float
static readonly "INSTANT": float
static readonly "UPDATE_LIMIT": integer
 "stateDefinition": $StateDefinition<($Block), ($BlockState)>
readonly "properties": $BlockBehaviour$Properties

constructor(arg0: $BlockBehaviour$Properties$Type)

public "getCloneItemStack"(arg0: $BlockState$Type, arg1: $HitResult$Type, arg2: $BlockGetter$Type, arg3: $BlockPos$Type, arg4: $Player$Type): $ItemStack
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
public "getUncamouflagedShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
public "getTicker"<T extends $BlockEntity>(arg0: $Level$Type, arg1: $BlockState$Type, arg2: $BlockEntityType$Type<(T)>): $BlockEntityTicker<(T)>
public "getListener"<T extends $BlockEntity>(arg0: $ServerLevel$Type, arg1: T): $GameEventListener
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TemplateFrameBlock$Type = ($TemplateFrameBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TemplateFrameBlock_ = $TemplateFrameBlock$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$FilterRoundRobinAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $FilterRoundRobinAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FilterRoundRobinAugment$Type = ($FilterRoundRobinAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FilterRoundRobinAugment_ = $FilterRoundRobinAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$PlacerModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $PlacerModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlacerModule$Type = ($PlacerModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlacerModule_ = $PlacerModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$EnergyOutputModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $EnergyOutputModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnergyOutputModule$Type = ($EnergyOutputModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnergyOutputModule_ = $EnergyOutputModule$Type;
}}
declare module "packages/me/desht/modularrouters/block/tile/$ICamouflageable" {
import {$BlockState, $BlockState$Type} from "packages/net/minecraft/world/level/block/state/$BlockState"

export interface $ICamouflageable {

 "extendedMimic"(): boolean
 "getCamouflage"(): $BlockState

(): boolean
}

export namespace $ICamouflageable {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICamouflageable$Type = ($ICamouflageable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICamouflageable_ = $ICamouflageable$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$EnergyDistributorModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$IPositionProvider, $IPositionProvider$Type} from "packages/me/desht/modularrouters/client/render/area/$IPositionProvider"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TargetedModule, $TargetedModule$Type} from "packages/me/desht/modularrouters/item/module/$TargetedModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $EnergyDistributorModule extends $TargetedModule implements $IRangedModule, $IPositionProvider {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getRenderColor"(arg0: integer): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnergyDistributorModule$Type = ($EnergyDistributorModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnergyDistributorModule_ = $EnergyDistributorModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$DetectorModule$SignalType" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $DetectorModule$SignalType extends $Enum<($DetectorModule$SignalType)> {
static readonly "NONE": $DetectorModule$SignalType
static readonly "WEAK": $DetectorModule$SignalType
static readonly "STRONG": $DetectorModule$SignalType


public static "values"(): ($DetectorModule$SignalType)[]
public static "valueOf"(arg0: string): $DetectorModule$SignalType
public static "getType"(arg0: boolean): $DetectorModule$SignalType
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DetectorModule$SignalType$Type = (("strong") | ("none") | ("weak")) | ($DetectorModule$SignalType);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DetectorModule$SignalType_ = $DetectorModule$SignalType$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$PickupDelayAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $PickupDelayAugment extends $AugmentItem {
static readonly "TICKS_PER_AUGMENT": integer
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraInfo"(arg0: integer, arg1: $ItemStack$Type): $Component
public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PickupDelayAugment$Type = ($PickupDelayAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PickupDelayAugment_ = $PickupDelayAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$ModItems$ITintable, $ModItems$ITintable$Type} from "packages/me/desht/modularrouters/core/$ModItems$ITintable"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$MRBaseItem, $MRBaseItem$Type} from "packages/me/desht/modularrouters/item/$MRBaseItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $UpgradeItem extends $MRBaseItem implements $ModItems$ITintable {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
public "onCompiled"(arg0: $ItemStack$Type, arg1: $ModularRouterBlockEntity$Type): void
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $UpgradeItem$Type = ($UpgradeItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $UpgradeItem_ = $UpgradeItem$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$PullerModule2" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$IPositionProvider, $IPositionProvider$Type} from "packages/me/desht/modularrouters/client/render/area/$IPositionProvider"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TargetedModule, $TargetedModule$Type} from "packages/me/desht/modularrouters/item/module/$TargetedModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $PullerModule2 extends $TargetedModule implements $IRangedModule, $IPositionProvider {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getRenderColor"(arg0: integer): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "directional"(): boolean
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PullerModule2$Type = ($PullerModule2);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PullerModule2_ = $PullerModule2$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$PullerModule1" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $PullerModule1 extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PullerModule1$Type = ($PullerModule1);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PullerModule1_ = $PullerModule1$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$RegexFilter" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$SmartFilterItem, $SmartFilterItem$Type} from "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RegexFilter extends $SmartFilterItem {
static readonly "MAX_SIZE": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
public "hasMenu"(): boolean
public static "getRegexList"(arg0: $ItemStack$Type): $List<(string)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegexFilter$Type = ($RegexFilter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegexFilter_ = $RegexFilter$Type;
}}
declare module "packages/me/desht/modularrouters/item/$MRBaseItem" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$Item$Properties, $Item$Properties$Type} from "packages/net/minecraft/world/item/$Item$Properties"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $MRBaseItem extends $Item {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor(arg0: $Item$Properties$Type)

public "appendHoverText"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MRBaseItem$Type = ($MRBaseItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MRBaseItem_ = $MRBaseItem$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$PlayerModule" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$ServerPlayer, $ServerPlayer$Type} from "packages/net/minecraft/server/level/$ServerPlayer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$IPlayerOwned, $IPlayerOwned$Type} from "packages/me/desht/modularrouters/item/$IPlayerOwned"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UseOnContext, $UseOnContext$Type} from "packages/net/minecraft/world/item/context/$UseOnContext"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $PlayerModule extends $ModuleItem implements $IPlayerOwned {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "useOn"(arg0: $UseOnContext$Type): $InteractionResult
public "getMenuType"(): $MenuType<(any)>
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
public "doModuleValidation"(arg0: $ItemStack$Type, arg1: $ServerPlayer$Type): void
public "setOwner"(arg0: $ItemStack$Type, arg1: $Player$Type): void
public "getOwnerName"(arg0: $ItemStack$Type): string
public "getOwnerID"(arg0: $ItemStack$Type): $UUID
get "menuType"(): $MenuType<(any)>
get "directional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PlayerModule$Type = ($PlayerModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PlayerModule_ = $PlayerModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$DetectorModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $DetectorModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "isOmniDirectional"(): boolean
public "getItemTint"(): $TintColor
get "menuType"(): $MenuType<(any)>
get "omniDirectional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DetectorModule$Type = ($DetectorModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DetectorModule_ = $DetectorModule$Type;
}}
declare module "packages/me/desht/modularrouters/util/fake_player/$RouterFakePlayer" {
import {$ServerGamePacketListenerImpl, $ServerGamePacketListenerImpl$Type} from "packages/net/minecraft/server/network/$ServerGamePacketListenerImpl"
import {$WalkAnimationState, $WalkAnimationState$Type} from "packages/net/minecraft/world/entity/$WalkAnimationState"
import {$ServerPlayerGameMode, $ServerPlayerGameMode$Type} from "packages/net/minecraft/server/level/$ServerPlayerGameMode"
import {$Abilities, $Abilities$Type} from "packages/net/minecraft/world/entity/player/$Abilities"
import {$FishingHook, $FishingHook$Type} from "packages/net/minecraft/world/entity/projectile/$FishingHook"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$EntityDataAccessor, $EntityDataAccessor$Type} from "packages/net/minecraft/network/syncher/$EntityDataAccessor"
import {$InventoryMenu, $InventoryMenu$Type} from "packages/net/minecraft/world/inventory/$InventoryMenu"
import {$FakePlayer, $FakePlayer$Type} from "packages/net/minecraftforge/common/util/$FakePlayer"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$RandomSource, $RandomSource$Type} from "packages/net/minecraft/util/$RandomSource"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$MinecraftServer, $MinecraftServer$Type} from "packages/net/minecraft/server/$MinecraftServer"
import {$EntityDimensions, $EntityDimensions$Type} from "packages/net/minecraft/world/entity/$EntityDimensions"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$ServerLevel, $ServerLevel$Type} from "packages/net/minecraft/server/level/$ServerLevel"
import {$GameProfile, $GameProfile$Type} from "packages/com/mojang/authlib/$GameProfile"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export class $RouterFakePlayer extends $FakePlayer {
 "connection": $ServerGamePacketListenerImpl
readonly "server": $MinecraftServer
readonly "gameMode": $ServerPlayerGameMode
 "lastSentHealth": float
 "lastSentFood": integer
 "lastSentExp": integer
 "isChangingDimension": boolean
 "enteredNetherPosition": $Vec3
 "containerCounter": integer
 "latency": integer
 "wonGame": boolean
static readonly "PERSISTED_NBT_TAG": string
static readonly "MAX_NAME_LENGTH": integer
static readonly "MAX_HEALTH": integer
static readonly "SLEEP_DURATION": integer
static readonly "WAKE_UP_DURATION": integer
static readonly "ENDER_SLOT_OFFSET": integer
static readonly "CROUCH_BB_HEIGHT": float
static readonly "SWIMMING_BB_WIDTH": float
static readonly "SWIMMING_BB_HEIGHT": float
static readonly "DEFAULT_EYE_HEIGHT": float
static readonly "STANDING_DIMENSIONS": $EntityDimensions
readonly "inventory": $Inventory
readonly "inventoryMenu": $InventoryMenu
 "containerMenu": $AbstractContainerMenu
 "oBob": float
 "bob": float
 "takeXpDelay": integer
 "xCloakO": double
 "yCloakO": double
 "zCloakO": double
 "xCloak": double
 "yCloak": double
 "zCloak": double
 "sleepCounter": integer
readonly "abilities": $Abilities
 "experienceLevel": integer
 "totalExperience": integer
 "experienceProgress": float
 "fishing": $FishingHook
static readonly "HAND_SLOTS": integer
static readonly "ARMOR_SLOTS": integer
static readonly "EQUIPMENT_SLOT_OFFSET": integer
static readonly "ARMOR_SLOT_OFFSET": integer
static readonly "SWING_DURATION": integer
static readonly "PLAYER_HURT_EXPERIENCE_TIME": integer
static readonly "MIN_MOVEMENT_DISTANCE": double
static readonly "DEFAULT_BASE_GRAVITY": double
static readonly "DEATH_DURATION": integer
static readonly "USE_ITEM_INTERVAL": integer
static readonly "DATA_HEALTH_ID": $EntityDataAccessor<(float)>
static readonly "EXTRA_RENDER_CULLING_SIZE_WITH_BIG_HAT": float
 "swinging": boolean
 "swingingArm": $InteractionHand
 "swingTime": integer
 "removeArrowTime": integer
 "removeStingerTime": integer
 "hurtTime": integer
 "hurtDuration": integer
 "deathTime": integer
 "oAttackAnim": float
 "attackAnim": float
 "attackStrengthTicker": integer
readonly "walkAnimation": $WalkAnimationState
readonly "invulnerableDuration": integer
readonly "timeOffs": float
readonly "rotA": float
 "yBodyRot": float
 "yBodyRotO": float
 "yHeadRot": float
 "yHeadRotO": float
 "lastHurtByPlayer": $Player
 "lastHurtByPlayerTime": integer
 "xxa": float
 "yya": float
 "zza": float
 "effectsDirty": boolean
 "autoSpinAttackTicks": integer
static readonly "ID_TAG": string
static readonly "PASSENGERS_TAG": string
static readonly "BOARDING_COOLDOWN": integer
static readonly "TOTAL_AIR_SUPPLY": integer
static readonly "MAX_ENTITY_TAG_COUNT": integer
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_0_2": float
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_0_5": double
static readonly "DELTA_AFFECTED_BY_BLOCKS_BELOW_1_0": double
static readonly "BREATHING_DISTANCE_BELOW_EYES": float
static readonly "BASE_TICKS_REQUIRED_TO_FREEZE": integer
static readonly "FREEZE_HURT_FREQUENCY": integer
static readonly "UUID_TAG": string
 "blocksBuilding": boolean
 "level": $Level
 "xo": double
 "yo": double
 "zo": double
 "yRot": float
 "xRot": float
 "yRotO": float
 "xRotO": float
 "horizontalCollision": boolean
 "verticalCollision": boolean
 "verticalCollisionBelow": boolean
 "minorHorizontalCollision": boolean
 "hurtMarked": boolean
static readonly "DEFAULT_BB_WIDTH": float
static readonly "DEFAULT_BB_HEIGHT": float
 "walkDistO": float
 "walkDist": float
 "moveDist": float
 "flyDist": float
 "fallDistance": float
 "xOld": double
 "yOld": double
 "zOld": double
 "noPhysics": boolean
readonly "random": $RandomSource
 "age": integer
 "remainingFireTicks": integer
 "invulnerableTime": integer
 "noCulling": boolean
 "hasImpulse": boolean
 "dimensions": $EntityDimensions
 "eyeHeight": float
 "isInPowderSnow": boolean
 "wasInPowderSnow": boolean
 "wasOnFire": boolean
 "mainSupportingBlockPos": $Optional<($BlockPos)>

constructor(arg0: $ModularRouterBlockEntity$Type, arg1: $ServerLevel$Type, arg2: $GameProfile$Type)

public "tick"(): void
public "getEyeY"(): double
public "position"(): $Vec3
public "isSilent"(): boolean
public "invokeSetSharedFlag"(arg0: integer, arg1: boolean): void
get "eyeY"(): double
get "silent"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RouterFakePlayer$Type = ($RouterFakePlayer);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RouterFakePlayer_ = $RouterFakePlayer$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$TargetedModule" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$ServerPlayer, $ServerPlayer$Type} from "packages/net/minecraft/server/level/$ServerPlayer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$UseOnContext, $UseOnContext$Type} from "packages/net/minecraft/world/item/context/$UseOnContext"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $TargetedModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer


public static "getTarget"(arg0: $ItemStack$Type): $ModuleTarget
public static "getTarget"(arg0: $ItemStack$Type, arg1: boolean): $ModuleTarget
public static "getTargets"(arg0: $ItemStack$Type, arg1: boolean): $Set<($ModuleTarget)>
public "onSneakRightClick"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $Player$Type, arg3: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "addUsageInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "useOn"(arg0: $UseOnContext$Type): $InteractionResult
public "doModuleValidation"(arg0: $ItemStack$Type, arg1: $ServerPlayer$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TargetedModule$Type = ($TargetedModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TargetedModule_ = $TargetedModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$DropperModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$BiFunction, $BiFunction$Type} from "packages/java/util/function/$BiFunction"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $DropperModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()
constructor(arg0: $BiFunction$Type<($ModularRouterBlockEntity$Type), ($ItemStack$Type), (any)>)

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DropperModule$Type = ($DropperModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DropperModule_ = $DropperModule$Type;
}}
declare module "packages/me/desht/modularrouters/logic/filter/matchers/$InspectionMatcher$Comparison" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export class $InspectionMatcher$Comparison implements $Predicate<($ItemStack)> {


public "toString"(): string
public "test"(arg0: $ItemStack$Type): boolean
public static "fromString"(arg0: string): $InspectionMatcher$Comparison
public "asLocalizedText"(): $Component
public "negate"(): $Predicate<($ItemStack)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
public static "isEqual"<T>(arg0: any): $Predicate<($ItemStack)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InspectionMatcher$Comparison$Type = ($InspectionMatcher$Comparison);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InspectionMatcher$Comparison_ = $InspectionMatcher$Comparison$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$BlastUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $BlastUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BlastUpgrade$Type = ($BlastUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BlastUpgrade_ = $BlastUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$FlingerModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$DropperModule, $DropperModule$Type} from "packages/me/desht/modularrouters/item/module/$DropperModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $FlingerModule extends $DropperModule {
static readonly "MIN_SPEED": float
static readonly "MAX_SPEED": float
static readonly "MIN_PITCH": float
static readonly "MAX_PITCH": float
static readonly "MIN_YAW": float
static readonly "MAX_YAW": float
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "getItemTint"(): $TintColor
get "menuType"(): $MenuType<(any)>
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FlingerModule$Type = ($FlingerModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FlingerModule_ = $FlingerModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$RegulatorAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RegulatorAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraInfo"(arg0: integer, arg1: $ItemStack$Type): $Component
public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RegulatorAugment$Type = ($RegulatorAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RegulatorAugment_ = $RegulatorAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$FastPickupAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $FastPickupAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FastPickupAugment$Type = ($FastPickupAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FastPickupAugment_ = $FastPickupAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$SpeedUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $SpeedUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraUsageParams"(): (any)[]
public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
get "extraUsageParams"(): (any)[]
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SpeedUpgrade$Type = ($SpeedUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SpeedUpgrade_ = $SpeedUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$SenderModule2" {
import {$IPositionProvider, $IPositionProvider$Type} from "packages/me/desht/modularrouters/client/render/area/$IPositionProvider"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TargetedModule, $TargetedModule$Type} from "packages/me/desht/modularrouters/item/module/$TargetedModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$BiFunction, $BiFunction$Type} from "packages/java/util/function/$BiFunction"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $SenderModule2 extends $TargetedModule implements $IRangedModule, $IPositionProvider {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()
constructor(arg0: $BiFunction$Type<($ModularRouterBlockEntity$Type), ($ItemStack$Type), (any)>)

public "getBaseRange"(): integer
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getRenderColor"(arg0: integer): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "directional"(): boolean
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SenderModule2$Type = ($SenderModule2);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SenderModule2_ = $SenderModule2$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$SenderModule1" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $SenderModule1 extends $ModuleItem implements $IRangedModule {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SenderModule1$Type = ($SenderModule1);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SenderModule1_ = $SenderModule1$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$SenderModule3" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IPositionProvider, $IPositionProvider$Type} from "packages/me/desht/modularrouters/client/render/area/$IPositionProvider"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TargetedModule, $TargetedModule$Type} from "packages/me/desht/modularrouters/item/module/$TargetedModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $SenderModule3 extends $TargetedModule implements $IPositionProvider {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
public "getRenderColor"(arg0: integer): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
get "directional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SenderModule3$Type = ($SenderModule3);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SenderModule3_ = $SenderModule3$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$MimicAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $MimicAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MimicAugment$Type = ($MimicAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MimicAugment_ = $MimicAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$CreativeModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $CreativeModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
get "directional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CreativeModule$Type = ($CreativeModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CreativeModule_ = $CreativeModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$FluidUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $FluidUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addUsageInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getExtraUsageParams"(): (any)[]
public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
get "extraUsageParams"(): (any)[]
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidUpgrade$Type = ($FluidUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidUpgrade_ = $FluidUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ModuleItem" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$BiFunction, $BiFunction$Type} from "packages/java/util/function/$BiFunction"
import {$LivingEntity, $LivingEntity$Type} from "packages/net/minecraft/world/entity/$LivingEntity"
import {$MutableComponent, $MutableComponent$Type} from "packages/net/minecraft/network/chat/$MutableComponent"
import {$ModItems$ITintable, $ModItems$ITintable$Type} from "packages/me/desht/modularrouters/core/$ModItems$ITintable"
import {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ServerPlayer, $ServerPlayer$Type} from "packages/net/minecraft/server/level/$ServerPlayer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$Item$Properties, $Item$Properties$Type} from "packages/net/minecraft/world/item/$Item$Properties"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$MRBaseItem, $MRBaseItem$Type} from "packages/me/desht/modularrouters/item/$MRBaseItem"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$CompiledModule, $CompiledModule$Type} from "packages/me/desht/modularrouters/logic/compiled/$CompiledModule"
import {$ModuleItem$RelativeDirection, $ModuleItem$RelativeDirection$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem$RelativeDirection"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ModuleItem extends $MRBaseItem implements $ModItems$ITintable {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor(arg0: $Item$Properties$Type, arg1: $BiFunction$Type<($ModularRouterBlockEntity$Type), ($ItemStack$Type), (any)>)

public "compile"(arg0: $ModularRouterBlockEntity$Type, arg1: $ItemStack$Type): $CompiledModule
public "isItemValidForFilter"(arg0: $ItemStack$Type): boolean
public "onEntitySwing"(arg0: $ItemStack$Type, arg1: $LivingEntity$Type): boolean
public "onSneakRightClick"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $Player$Type, arg3: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "getFilterItemMatcher"(arg0: $ItemStack$Type): $IItemMatcher
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "isFoil"(arg0: $ItemStack$Type): boolean
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public "getMenuType"(): $MenuType<(any)>
public "isDirectional"(): boolean
public "getRegulatorTranslationKey"(arg0: $ItemStack$Type): string
public "isFluidModule"(): boolean
public "isOmniDirectional"(): boolean
public "getItemTint"(): $TintColor
public "getDirectionString"(arg0: $ModuleItem$RelativeDirection$Type): $MutableComponent
public "doModuleValidation"(arg0: $ItemStack$Type, arg1: $ServerPlayer$Type): void
get "menuType"(): $MenuType<(any)>
get "directional"(): boolean
get "fluidModule"(): boolean
get "omniDirectional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModuleItem$Type = ($ModuleItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModuleItem_ = $ModuleItem$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem" {
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$MRBaseItem, $MRBaseItem$Type} from "packages/me/desht/modularrouters/item/$MRBaseItem"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$AbstractSmartFilterMenu, $AbstractSmartFilterMenu$Type} from "packages/me/desht/modularrouters/container/$AbstractSmartFilterMenu"

export class $SmartFilterItem extends $MRBaseItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public "createMenu"(arg0: integer, arg1: $Inventory$Type, arg2: $MFLocator$Type): $AbstractSmartFilterMenu
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
public "hasMenu"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SmartFilterItem$Type = ($SmartFilterItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SmartFilterItem_ = $SmartFilterItem$Type;
}}
declare module "packages/me/desht/modularrouters/util/$BeamData" {
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Vec3, $Vec3$Type} from "packages/net/minecraft/world/phys/$Vec3"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$AABB, $AABB$Type} from "packages/net/minecraft/world/phys/$AABB"

export class $BeamData {

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

public "toBytes"(arg0: $FriendlyByteBuf$Type, arg1: $BlockPos$Type): void
public "getStack"(): $ItemStack
public "tick"(): void
public "getProgress"(arg0: float): float
public "isExpired"(): boolean
public "getStart"(arg0: $Vec3$Type): $Vec3
public "getRGB"(): (integer)[]
public "reverseItems"(): $BeamData
public "fadeItems"(): $BeamData
public "getAABB"(arg0: $BlockPos$Type): $AABB
public "getEnd"(arg0: $Vec3$Type): $Vec3
public "isItemFade"(): boolean
get "stack"(): $ItemStack
get "expired"(): boolean
get "rGB"(): (integer)[]
get "itemFade"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BeamData$Type = ($BeamData);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BeamData_ = $BeamData$Type;
}}
declare module "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher" {
import {$Fluid, $Fluid$Type} from "packages/net/minecraft/world/level/material/$Fluid"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Filter$Flags, $Filter$Flags$Type} from "packages/me/desht/modularrouters/logic/filter/$Filter$Flags"

export interface $IItemMatcher {

 "matchItem"(arg0: $ItemStack$Type, arg1: $Filter$Flags$Type): boolean
 "matchFluid"(arg0: $Fluid$Type, arg1: $Filter$Flags$Type): boolean

(arg0: $ItemStack$Type, arg1: $Filter$Flags$Type): boolean
}

export namespace $IItemMatcher {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IItemMatcher$Type = ($IItemMatcher);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IItemMatcher_ = $IItemMatcher$Type;
}}
declare module "packages/me/desht/modularrouters/logic/filter/$Filter" {
import {$Fluid, $Fluid$Type} from "packages/net/minecraft/world/level/material/$Fluid"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Filter$Flags, $Filter$Flags$Type} from "packages/me/desht/modularrouters/logic/filter/$Filter$Flags"

export class $Filter implements $Predicate<($ItemStack)> {
static readonly "FILTER_SIZE": integer

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

public "test"(arg0: $ItemStack$Type): boolean
public "isEmpty"(): boolean
public "getFlags"(): $Filter$Flags
public "getRawStacks"(): $List<($ItemStack)>
public "testFluid"(arg0: $Fluid$Type): boolean
public "cycleRoundRobin"(): $Optional<(integer)>
public "isBlacklist"(): boolean
public "negate"(): $Predicate<($ItemStack)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
public static "isEqual"<T>(arg0: any): $Predicate<($ItemStack)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<($ItemStack)>
get "empty"(): boolean
get "flags"(): $Filter$Flags
get "rawStacks"(): $List<($ItemStack)>
get "blacklist"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Filter$Type = ($Filter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Filter_ = $Filter$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$RangeAugments$RangeUpAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$RangeAugments, $RangeAugments$Type} from "packages/me/desht/modularrouters/item/augment/$RangeAugments"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RangeAugments$RangeUpAugment extends $RangeAugments {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RangeAugments$RangeUpAugment$Type = ($RangeAugments$RangeUpAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RangeAugments$RangeUpAugment_ = $RangeAugments$RangeUpAugment$Type;
}}
declare module "packages/me/desht/modularrouters/logic/filter/$Filter$Flags" {
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export class $Filter$Flags {
static readonly "DEFAULT_FLAGS": $Filter$Flags

constructor(arg0: $ItemStack$Type)
constructor()

public "isIgnoreDamage"(): boolean
public "isBlacklist"(): boolean
public "isIgnoreNBT"(): boolean
public "matchTags"(): boolean
get "ignoreDamage"(): boolean
get "blacklist"(): boolean
get "ignoreNBT"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Filter$Flags$Type = ($Filter$Flags);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Filter$Flags_ = $Filter$Flags$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$XPVacuumAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $XPVacuumAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $XPVacuumAugment$Type = ($XPVacuumAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $XPVacuumAugment_ = $XPVacuumAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$EnergyUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $EnergyUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addUsageInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $EnergyUpgrade$Type = ($EnergyUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $EnergyUpgrade_ = $EnergyUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity" {
import {$SoundEvent, $SoundEvent$Type} from "packages/net/minecraft/sounds/$SoundEvent"
import {$ModularRouterBlockEntity$EnergyDirection, $ModularRouterBlockEntity$EnergyDirection$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity$EnergyDirection"
import {$LazyOptional, $LazyOptional$Type} from "packages/net/minecraftforge/common/util/$LazyOptional"
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$Connection, $Connection$Type} from "packages/net/minecraft/network/$Connection"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$IEnergyStorage, $IEnergyStorage$Type} from "packages/net/minecraftforge/energy/$IEnergyStorage"
import {$RouterFakePlayer, $RouterFakePlayer$Type} from "packages/me/desht/modularrouters/util/fake_player/$RouterFakePlayer"
import {$RouterRedstoneBehaviour, $RouterRedstoneBehaviour$Type} from "packages/me/desht/modularrouters/logic/$RouterRedstoneBehaviour"
import {$ClientboundBlockEntityDataPacket, $ClientboundBlockEntityDataPacket$Type} from "packages/net/minecraft/network/protocol/game/$ClientboundBlockEntityDataPacket"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$DetectorModule$SignalType, $DetectorModule$SignalType$Type} from "packages/me/desht/modularrouters/item/module/$DetectorModule$SignalType"
import {$SoundSource, $SoundSource$Type} from "packages/net/minecraft/sounds/$SoundSource"
import {$FluidModule1$FluidDirection, $FluidModule1$FluidDirection$Type} from "packages/me/desht/modularrouters/item/module/$FluidModule1$FluidDirection"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$List, $List$Type} from "packages/java/util/$List"
import {$GameProfile, $GameProfile$Type} from "packages/com/mojang/authlib/$GameProfile"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$AABB, $AABB$Type} from "packages/net/minecraft/world/phys/$AABB"
import {$ModelData, $ModelData$Type} from "packages/net/minecraftforge/client/model/data/$ModelData"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$BlockState, $BlockState$Type} from "packages/net/minecraft/world/level/block/state/$BlockState"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$IItemHandler, $IItemHandler$Type} from "packages/net/minecraftforge/items/$IItemHandler"
import {$Capability, $Capability$Type} from "packages/net/minecraftforge/common/capabilities/$Capability"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$BeamData, $BeamData$Type} from "packages/me/desht/modularrouters/util/$BeamData"
import {$GlobalPos, $GlobalPos$Type} from "packages/net/minecraft/core/$GlobalPos"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$ModularRouterBlockEntity$TrackedEnergy, $ModularRouterBlockEntity$TrackedEnergy$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity$TrackedEnergy"
import {$MenuProvider, $MenuProvider$Type} from "packages/net/minecraft/world/$MenuProvider"
import {$ModuleItem$RelativeDirection, $ModuleItem$RelativeDirection$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem$RelativeDirection"
import {$ICamouflageable, $ICamouflageable$Type} from "packages/me/desht/modularrouters/block/tile/$ICamouflageable"

export class $ModularRouterBlockEntity extends $BlockEntity implements $ICamouflageable, $MenuProvider {
static readonly "DEFAULT_FAKEPLAYER_PROFILE": $GameProfile
static readonly "COMPILE_MODULES": integer
static readonly "COMPILE_UPGRADES": integer
static readonly "NBT_MODULES": string
static readonly "NBT_UPGRADES": string
static readonly "NBT_REDSTONE_MODE": string
readonly "trackedEnergy": $ModularRouterBlockEntity$TrackedEnergy
readonly "beams": $List<($BeamData)>
readonly "pendingBeams": $List<($BeamData)>

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

public "getBuffer"(): $IItemHandler
public "getCapability"<T>(arg0: $Capability$Type<(T)>, arg1: $Direction$Type): $LazyOptional<(T)>
public "getModules"(): $IItemHandler
public "getModelData"(): $ModelData
public "onDataPacket"(arg0: $Connection$Type, arg1: $ClientboundBlockEntityDataPacket$Type): void
public "handleUpdateTag"(arg0: $CompoundTag$Type): void
public "getUpdatePacket"(): $ClientboundBlockEntityDataPacket
public "isPermitted"(arg0: $Player$Type): boolean
public "createMenu"(arg0: integer, arg1: $Inventory$Type, arg2: $Player$Type): $AbstractContainerMenu
public "playSound"(arg0: $Player$Type, arg1: $BlockPos$Type, arg2: $SoundEvent$Type, arg3: $SoundSource$Type, arg4: float, arg5: float): void
public "getRenderBoundingBox"(): $AABB
public "serverTick"(): void
public "setRemoved"(): void
public "getUpdateTag"(): $CompoundTag
public "load"(arg0: $CompoundTag$Type): void
public "m_183515_"(arg0: $CompoundTag$Type): void
public "getUpgradeCount"(arg0: $Item$Type): integer
public "clientTick"(): void
public "getGlobalPos"(): $GlobalPos
public "getDisplayName"(): $Component
public "getFakePlayer"(): $RouterFakePlayer
public "getUpgrades"(): $IItemHandler
public "getEnergyCapacity"(): integer
public "getRedstoneLevel"(arg0: $Direction$Type, arg1: boolean): integer
public "nonNullLevel"(): $Level
public "getBufferItemStack"(): $ItemStack
public "getExtensionData"(): $CompoundTag
public "transferredFluid"(arg0: integer, arg1: $FluidModule1$FluidDirection$Type): void
public "setEcoMode"(arg0: boolean): void
public "getAbsoluteFacing"(arg0: $ModuleItem$RelativeDirection$Type): $Direction
public "emitRedstone"(arg0: $ModuleItem$RelativeDirection$Type, arg1: integer, arg2: $DetectorModule$SignalType$Type): void
public "setBufferItemStack"(arg0: $ItemStack$Type): void
public "extractBuffer"(arg0: integer): $ItemStack
public "addItemBeam"(arg0: $BeamData$Type): void
public "setUpgradesFrom"(arg0: $IItemHandler$Type): void
public "insertBuffer"(arg0: $ItemStack$Type): $ItemStack
public "getEcoMode"(): boolean
public "peekBuffer"(arg0: integer): $ItemStack
public "getEnergyDirection"(): $ModularRouterBlockEntity$EnergyDirection
public "setEnergyDirection"(arg0: $ModularRouterBlockEntity$EnergyDirection$Type): void
public "getBufferSlotCount"(): integer
public "getModuleCount"(): integer
public "getEnergyStorage"(): $IEnergyStorage
public "getFluidTransferRate"(): integer
public "checkForRedstonePulse"(): void
public "getUpgradeSlotCount"(): integer
public "getRedstonePower"(): integer
public "getCurrentFluidTransferAllowance"(arg0: $FluidModule1$FluidDirection$Type): integer
public "setRedstoneBehaviour"(arg0: $RouterRedstoneBehaviour$Type): void
public "caresAboutItemAttributes"(): boolean
public "setHasPulsedModules"(arg0: boolean): void
public "setAllowRedstoneEmission"(arg0: boolean): void
public "getRedstoneBehaviour"(): $RouterRedstoneBehaviour
public "setCamouflage"(arg0: $BlockState$Type): void
public "getEnergyXferRate"(): integer
public "getCamouflage"(): $BlockState
public "notifyModules"(): void
public "getModuleSlotCount"(): integer
public "addPermittedIds"(arg0: $Set$Type<($UUID$Type)>): void
public "getItemsPerTick"(): integer
public "getTickRate"(): integer
public "setTunedSyncValue"(arg0: integer): void
public "recompileNeeded"(arg0: integer): void
public "isBufferFull"(): boolean
public "isBufferEmpty"(): boolean
public "extendedMimic"(): boolean
get "buffer"(): $IItemHandler
get "modules"(): $IItemHandler
get "modelData"(): $ModelData
get "updatePacket"(): $ClientboundBlockEntityDataPacket
get "renderBoundingBox"(): $AABB
get "updateTag"(): $CompoundTag
get "globalPos"(): $GlobalPos
get "displayName"(): $Component
get "fakePlayer"(): $RouterFakePlayer
get "upgrades"(): $IItemHandler
get "energyCapacity"(): integer
get "bufferItemStack"(): $ItemStack
get "extensionData"(): $CompoundTag
set "ecoMode"(value: boolean)
set "bufferItemStack"(value: $ItemStack$Type)
set "upgradesFrom"(value: $IItemHandler$Type)
get "ecoMode"(): boolean
get "energyDirection"(): $ModularRouterBlockEntity$EnergyDirection
set "energyDirection"(value: $ModularRouterBlockEntity$EnergyDirection$Type)
get "bufferSlotCount"(): integer
get "moduleCount"(): integer
get "energyStorage"(): $IEnergyStorage
get "fluidTransferRate"(): integer
get "upgradeSlotCount"(): integer
get "redstonePower"(): integer
set "redstoneBehaviour"(value: $RouterRedstoneBehaviour$Type)
set "hasPulsedModules"(value: boolean)
set "allowRedstoneEmission"(value: boolean)
get "redstoneBehaviour"(): $RouterRedstoneBehaviour
set "camouflage"(value: $BlockState$Type)
get "energyXferRate"(): integer
get "camouflage"(): $BlockState
get "moduleSlotCount"(): integer
get "itemsPerTick"(): integer
get "tickRate"(): integer
set "tunedSyncValue"(value: integer)
get "bufferFull"(): boolean
get "bufferEmpty"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularRouterBlockEntity$Type = ($ModularRouterBlockEntity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularRouterBlockEntity_ = $ModularRouterBlockEntity$Type;
}}
declare module "packages/me/desht/modularrouters/network/$FilterSettingsMessage$Operation" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $FilterSettingsMessage$Operation extends $Enum<($FilterSettingsMessage$Operation)> {
static readonly "CLEAR_ALL": $FilterSettingsMessage$Operation
static readonly "REMOVE_ITEM": $FilterSettingsMessage$Operation
static readonly "MERGE": $FilterSettingsMessage$Operation
static readonly "LOAD": $FilterSettingsMessage$Operation
static readonly "ADD_STRING": $FilterSettingsMessage$Operation
static readonly "REMOVE_AT": $FilterSettingsMessage$Operation
static readonly "ANY_ALL_FLAG": $FilterSettingsMessage$Operation


public static "values"(): ($FilterSettingsMessage$Operation)[]
public static "valueOf"(arg0: string): $FilterSettingsMessage$Operation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FilterSettingsMessage$Operation$Type = (("remove_at") | ("load") | ("any_all_flag") | ("remove_item") | ("add_string") | ("merge") | ("clear_all")) | ($FilterSettingsMessage$Operation);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FilterSettingsMessage$Operation_ = $FilterSettingsMessage$Operation$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$RangeAugments" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RangeAugments extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RangeAugments$Type = ($RangeAugments);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RangeAugments_ = $RangeAugments$Type;
}}
declare module "packages/me/desht/modularrouters/logic/compiled/$CompiledModule" {
import {$ModuleItem$Termination, $ModuleItem$Termination$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem$Termination"
import {$Filter, $Filter$Type} from "packages/me/desht/modularrouters/logic/filter/$Filter"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$ModuleItem$RelativeDirection, $ModuleItem$RelativeDirection$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem$RelativeDirection"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $CompiledModule {


public "execute"(arg0: $ModularRouterBlockEntity$Type): boolean
public "cleanup"(arg0: $ModularRouterBlockEntity$Type): void
public "getFilter"(): $Filter
public "termination"(): $ModuleItem$Termination
public "getDirection"(): $ModuleItem$RelativeDirection
public "getEnergyCost"(): integer
public "shouldRun"(arg0: boolean, arg1: boolean): boolean
public "hasTarget"(): boolean
public "onNeighbourChange"(arg0: $ModularRouterBlockEntity$Type): void
public "getRegulationAmount"(): integer
public "careAboutItemAttributes"(): boolean
public "getEffectiveTarget"(arg0: $ModularRouterBlockEntity$Type): $ModuleTarget
public "onCompiled"(arg0: $ModularRouterBlockEntity$Type): void
get "filter"(): $Filter
get "direction"(): $ModuleItem$RelativeDirection
get "energyCost"(): integer
get "regulationAmount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CompiledModule$Type = ($CompiledModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CompiledModule_ = $CompiledModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$RangeAugments$RangeDownAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$RangeAugments, $RangeAugments$Type} from "packages/me/desht/modularrouters/item/augment/$RangeAugments"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RangeAugments$RangeDownAugment extends $RangeAugments {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RangeAugments$RangeDownAugment$Type = ($RangeAugments$RangeDownAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RangeAugments$RangeDownAugment_ = $RangeAugments$RangeDownAugment$Type;
}}
declare module "packages/me/desht/modularrouters/block/$ModularRouterBlock" {
import {$BooleanProperty, $BooleanProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$BooleanProperty"
import {$EntityBlock, $EntityBlock$Type} from "packages/net/minecraft/world/level/block/$EntityBlock"
import {$CamouflageableBlock, $CamouflageableBlock$Type} from "packages/me/desht/modularrouters/block/$CamouflageableBlock"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$Mirror, $Mirror$Type} from "packages/net/minecraft/world/level/block/$Mirror"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$FluidState, $FluidState$Type} from "packages/net/minecraft/world/level/material/$FluidState"
import {$BlockGetter, $BlockGetter$Type} from "packages/net/minecraft/world/level/$BlockGetter"
import {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$List, $List$Type} from "packages/java/util/$List"
import {$BlockHitResult, $BlockHitResult$Type} from "packages/net/minecraft/world/phys/$BlockHitResult"
import {$ServerLevel, $ServerLevel$Type} from "packages/net/minecraft/server/level/$ServerLevel"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$BlockPlaceContext, $BlockPlaceContext$Type} from "packages/net/minecraft/world/item/context/$BlockPlaceContext"
import {$DirectionProperty, $DirectionProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$DirectionProperty"
import {$ModelProperty, $ModelProperty$Type} from "packages/net/minecraftforge/client/model/data/$ModelProperty"
import {$Entity, $Entity$Type} from "packages/net/minecraft/world/entity/$Entity"
import {$VoxelShape, $VoxelShape$Type} from "packages/net/minecraft/world/phys/shapes/$VoxelShape"
import {$CollisionContext, $CollisionContext$Type} from "packages/net/minecraft/world/phys/shapes/$CollisionContext"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$BlockState, $BlockState$Type} from "packages/net/minecraft/world/level/block/state/$BlockState"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$BlockEntityType, $BlockEntityType$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntityType"
import {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$Rotation, $Rotation$Type} from "packages/net/minecraft/world/level/block/$Rotation"
import {$Explosion, $Explosion$Type} from "packages/net/minecraft/world/level/$Explosion"
import {$BlockEntityTicker, $BlockEntityTicker$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntityTicker"
import {$GameEventListener, $GameEventListener$Type} from "packages/net/minecraft/world/level/gameevent/$GameEventListener"
import {$BlockAndTintGetter, $BlockAndTintGetter$Type} from "packages/net/minecraft/world/level/$BlockAndTintGetter"

export class $ModularRouterBlock extends $CamouflageableBlock implements $EntityBlock {
static readonly "FACING": $DirectionProperty
static readonly "ACTIVE": $BooleanProperty
static readonly "CAN_EMIT": $BooleanProperty
static readonly "CAMOUFLAGE_STATE": $ModelProperty<($BlockState)>
/**
 * 
 * @deprecated
 */
static readonly "BLOCK_STATE_REGISTRY": $IdMapper<($BlockState)>
static readonly "UPDATE_NEIGHBORS": integer
static readonly "UPDATE_CLIENTS": integer
static readonly "UPDATE_INVISIBLE": integer
static readonly "UPDATE_IMMEDIATE": integer
static readonly "UPDATE_KNOWN_SHAPE": integer
static readonly "UPDATE_SUPPRESS_DROPS": integer
static readonly "UPDATE_MOVE_BY_PISTON": integer
static readonly "UPDATE_NONE": integer
static readonly "UPDATE_ALL": integer
static readonly "UPDATE_ALL_IMMEDIATE": integer
static readonly "INDESTRUCTIBLE": float
static readonly "INSTANT": float
static readonly "UPDATE_LIMIT": integer
 "stateDefinition": $StateDefinition<($Block), ($BlockState)>
readonly "properties": $BlockBehaviour$Properties

constructor(arg0: $BlockBehaviour$Properties$Type)

public "getExplosionResistance"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Explosion$Type): float
public "shouldDisplayFluidOverlay"(arg0: $BlockState$Type, arg1: $BlockAndTintGetter$Type, arg2: $BlockPos$Type, arg3: $FluidState$Type): boolean
public "neighborChanged"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $Block$Type, arg4: $BlockPos$Type, arg5: boolean): void
public "onRemove"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
public "isSignalSource"(arg0: $BlockState$Type): boolean
public "use"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $Player$Type, arg4: $InteractionHand$Type, arg5: $BlockHitResult$Type): $InteractionResult
public "hasAnalogOutputSignal"(arg0: $BlockState$Type): boolean
public "rotate"(arg0: $BlockState$Type, arg1: $Rotation$Type): $BlockState
public "mirror"(arg0: $BlockState$Type, arg1: $Mirror$Type): $BlockState
public "getAnalogOutputSignal"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type): integer
public "getSignal"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Direction$Type): integer
public "getDirectSignal"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Direction$Type): integer
public "getTicker"<T extends $BlockEntity>(arg0: $Level$Type, arg1: $BlockState$Type, arg2: $BlockEntityType$Type<(T)>): $BlockEntityTicker<(T)>
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $BlockGetter$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public "canEntityDestroy"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Entity$Type): boolean
public "getStateForPlacement"(arg0: $BlockPlaceContext$Type): $BlockState
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
public "getUncamouflagedShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
public "getListener"<T extends $BlockEntity>(arg0: $ServerLevel$Type, arg1: T): $GameEventListener
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularRouterBlock$Type = ($ModularRouterBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularRouterBlock_ = $ModularRouterBlock$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$BreakerModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$IPickaxeUser, $IPickaxeUser$Type} from "packages/me/desht/modularrouters/item/module/$IPickaxeUser"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $BreakerModule extends $ModuleItem implements $IPickaxeUser {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "getItemTint"(): $TintColor
public "getPickaxe"(arg0: $ItemStack$Type): $ItemStack
public "setPickaxe"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $ItemStack
get "menuType"(): $MenuType<(any)>
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BreakerModule$Type = ($BreakerModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BreakerModule_ = $BreakerModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$SyncUpgrade" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $SyncUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "getItemTint"(): $TintColor
public "onCompiled"(arg0: $ItemStack$Type, arg1: $ModularRouterBlockEntity$Type): void
public static "getTunedValue"(arg0: $ItemStack$Type): integer
public static "setTunedValue"(arg0: $ItemStack$Type, arg1: integer): void
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SyncUpgrade$Type = ($SyncUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SyncUpgrade_ = $SyncUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$AugmentItem" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$MRBaseItem, $MRBaseItem$Type} from "packages/me/desht/modularrouters/item/$MRBaseItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $AugmentItem extends $MRBaseItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraInfo"(arg0: integer, arg1: $ItemStack$Type): $Component
public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AugmentItem$Type = ($AugmentItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AugmentItem_ = $AugmentItem$Type;
}}
declare module "packages/me/desht/modularrouters/container/$AbstractMRContainerMenu" {
import {$NonNullList, $NonNullList$Type} from "packages/net/minecraft/core/$NonNullList"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Slot, $Slot$Type} from "packages/net/minecraft/world/inventory/$Slot"
import {$ContainerListener, $ContainerListener$Type} from "packages/net/minecraft/world/inventory/$ContainerListener"
import {$AbstractContainerMenu, $AbstractContainerMenu$Type} from "packages/net/minecraft/world/inventory/$AbstractContainerMenu"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export class $AbstractMRContainerMenu extends $AbstractContainerMenu {
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)>


}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AbstractMRContainerMenu$Type = ($AbstractMRContainerMenu);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AbstractMRContainerMenu_ = $AbstractMRContainerMenu$Type;
}}
declare module "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity$EnergyDirection" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IHasTranslationKey, $IHasTranslationKey$Type} from "packages/me/desht/modularrouters/client/util/$IHasTranslationKey"

export class $ModularRouterBlockEntity$EnergyDirection extends $Enum<($ModularRouterBlockEntity$EnergyDirection)> implements $IHasTranslationKey {
static readonly "FROM_ROUTER": $ModularRouterBlockEntity$EnergyDirection
static readonly "TO_ROUTER": $ModularRouterBlockEntity$EnergyDirection
static readonly "NONE": $ModularRouterBlockEntity$EnergyDirection


public static "values"(): ($ModularRouterBlockEntity$EnergyDirection)[]
public static "valueOf"(arg0: string): $ModularRouterBlockEntity$EnergyDirection
public "getTranslationKey"(): string
public static "forValue"(arg0: string): $ModularRouterBlockEntity$EnergyDirection
get "translationKey"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModularRouterBlockEntity$EnergyDirection$Type = (("from_router") | ("none") | ("to_router")) | ($ModularRouterBlockEntity$EnergyDirection);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModularRouterBlockEntity$EnergyDirection_ = $ModularRouterBlockEntity$EnergyDirection$Type;
}}
declare module "packages/me/desht/modularrouters/core/$ModItems$ITintable" {
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"

export interface $ModItems$ITintable {

 "getItemTint"(): $TintColor

(): $TintColor
}

export namespace $ModItems$ITintable {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModItems$ITintable$Type = ($ModItems$ITintable);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModItems$ITintable_ = $ModItems$ITintable$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$InspectionFilter" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$SmartFilterItem, $SmartFilterItem$Type} from "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$InspectionMatcher$ComparisonList, $InspectionMatcher$ComparisonList$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$InspectionMatcher$ComparisonList"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $InspectionFilter extends $SmartFilterItem {
static readonly "NBT_COMPARISON": string
static readonly "MAX_SIZE": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
public "hasMenu"(): boolean
public static "getComparisonList"(arg0: $ItemStack$Type): $InspectionMatcher$ComparisonList
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InspectionFilter$Type = ($InspectionFilter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InspectionFilter_ = $InspectionFilter$Type;
}}
declare module "packages/me/desht/modularrouters/logic/filter/matchers/$InspectionMatcher$ComparisonList" {
import {$InspectionMatcher$Comparison, $InspectionMatcher$Comparison$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$InspectionMatcher$Comparison"
import {$List, $List$Type} from "packages/java/util/$List"

export class $InspectionMatcher$ComparisonList {
readonly "items": $List<($InspectionMatcher$Comparison)>

constructor(arg0: $List$Type<($InspectionMatcher$Comparison$Type)>, arg1: boolean)

public "isMatchAll"(): boolean
public "setMatchAll"(arg0: boolean): void
get "matchAll"(): boolean
set "matchAll"(value: boolean)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InspectionMatcher$ComparisonList$Type = ($InspectionMatcher$ComparisonList);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InspectionMatcher$ComparisonList_ = $InspectionMatcher$ComparisonList$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$SecurityUpgrade" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$IPlayerOwned, $IPlayerOwned$Type} from "packages/me/desht/modularrouters/item/$IPlayerOwned"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$LivingEntity, $LivingEntity$Type} from "packages/net/minecraft/world/entity/$LivingEntity"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $SecurityUpgrade extends $UpgradeItem implements $IPlayerOwned {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "interactLivingEntity"(arg0: $ItemStack$Type, arg1: $Player$Type, arg2: $LivingEntity$Type, arg3: $InteractionHand$Type): $InteractionResult
public "getItemTint"(): $TintColor
public "onCompiled"(arg0: $ItemStack$Type, arg1: $ModularRouterBlockEntity$Type): void
public "setOwner"(arg0: $ItemStack$Type, arg1: $Player$Type): void
public "getOwnerName"(arg0: $ItemStack$Type): string
public "getOwnerID"(arg0: $ItemStack$Type): $UUID
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SecurityUpgrade$Type = ($SecurityUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SecurityUpgrade_ = $SecurityUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$RedstoneAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $RedstoneAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraInfo"(arg0: integer, arg1: $ItemStack$Type): $Component
public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RedstoneAugment$Type = ($RedstoneAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RedstoneAugment_ = $RedstoneAugment$Type;
}}
declare module "packages/me/desht/modularrouters/util/$MFLocator" {
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export class $MFLocator {
readonly "hand": $InteractionHand
readonly "routerPos": $BlockPos
readonly "routerSlot": integer
readonly "filterSlot": integer


public static "fromBuffer"(arg0: $FriendlyByteBuf$Type): $MFLocator
public static "filterInHeldModule"(arg0: $InteractionHand$Type, arg1: integer): $MFLocator
public static "moduleInRouter"(arg0: $BlockPos$Type, arg1: integer): $MFLocator
public static "heldModule"(arg0: $InteractionHand$Type): $MFLocator
public "writeBuf"(arg0: $FriendlyByteBuf$Type): void
public static "heldFilter"(arg0: $InteractionHand$Type): $MFLocator
public "getTargetItem"(arg0: $Player$Type): $ItemStack
public "getRouter"(arg0: $Level$Type): $Optional<($ModularRouterBlockEntity)>
public "getModuleStack"(arg0: $Player$Type): $ItemStack
public static "filterInInstalledModule"(arg0: $BlockPos$Type, arg1: integer, arg2: integer): $MFLocator
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $MFLocator$Type = ($MFLocator);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $MFLocator_ = $MFLocator$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$VoidModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $VoidModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "isDirectional"(): boolean
public "getItemTint"(): $TintColor
get "directional"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VoidModule$Type = ($VoidModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VoidModule_ = $VoidModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$IPickaxeUser" {
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export interface $IPickaxeUser {

 "getPickaxe"(arg0: $ItemStack$Type): $ItemStack
 "setPickaxe"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $ItemStack
}

export namespace $IPickaxeUser {
const NBT_PICKAXE: string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPickaxeUser$Type = ($IPickaxeUser);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPickaxeUser_ = $IPickaxeUser$Type;
}}
declare module "packages/me/desht/modularrouters/network/$FilterSettingsMessage" {
import {$NetworkEvent$Context, $NetworkEvent$Context$Type} from "packages/net/minecraftforge/network/$NetworkEvent$Context"
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$LazyOptional, $LazyOptional$Type} from "packages/net/minecraftforge/common/util/$LazyOptional"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$IItemHandler, $IItemHandler$Type} from "packages/net/minecraftforge/items/$IItemHandler"
import {$FilterSettingsMessage$Operation, $FilterSettingsMessage$Operation$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage$Operation"
import {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"

export class $FilterSettingsMessage {

constructor(arg0: $FilterSettingsMessage$Operation$Type, arg1: $MFLocator$Type, arg2: $CompoundTag$Type)
constructor(arg0: $FriendlyByteBuf$Type)

public "toBytes"(arg0: $FriendlyByteBuf$Type): void
public "handle"(arg0: $Supplier$Type<($NetworkEvent$Context$Type)>): void
public "getPayload"(): $CompoundTag
public "getTargetInventory"(): $LazyOptional<($IItemHandler)>
public "getOp"(): $FilterSettingsMessage$Operation
get "payload"(): $CompoundTag
get "targetInventory"(): $LazyOptional<($IItemHandler)>
get "op"(): $FilterSettingsMessage$Operation
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FilterSettingsMessage$Type = ($FilterSettingsMessage);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FilterSettingsMessage_ = $FilterSettingsMessage$Type;
}}
declare module "packages/me/desht/modularrouters/item/$IPlayerOwned" {
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export interface $IPlayerOwned {

 "setOwner"(arg0: $ItemStack$Type, arg1: $Player$Type): void
 "getOwnerName"(arg0: $ItemStack$Type): string
 "getOwnerID"(arg0: $ItemStack$Type): $UUID
}

export namespace $IPlayerOwned {
const NBT_OWNER: string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPlayerOwned$Type = ($IPlayerOwned);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPlayerOwned_ = $IPlayerOwned$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$StackAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $StackAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraInfo"(arg0: integer, arg1: $ItemStack$Type): $Component
public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StackAugment$Type = ($StackAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StackAugment_ = $StackAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$FluidModule1" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $FluidModule1 extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "isItemValidForFilter"(arg0: $ItemStack$Type): boolean
public "getFilterItemMatcher"(arg0: $ItemStack$Type): $IItemMatcher
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "getRegulatorTranslationKey"(arg0: $ItemStack$Type): string
public "isFluidModule"(): boolean
public "getItemTint"(): $TintColor
get "menuType"(): $MenuType<(any)>
get "fluidModule"(): boolean
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidModule1$Type = ($FluidModule1);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidModule1_ = $FluidModule1$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$FluidModule2" {
import {$IPositionProvider, $IPositionProvider$Type} from "packages/me/desht/modularrouters/client/render/area/$IPositionProvider"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TargetedModule, $TargetedModule$Type} from "packages/me/desht/modularrouters/item/module/$TargetedModule"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $FluidModule2 extends $TargetedModule implements $IRangedModule, $IPositionProvider {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "isItemValidForFilter"(arg0: $ItemStack$Type): boolean
public "getBaseRange"(): integer
public "getFilterItemMatcher"(arg0: $ItemStack$Type): $IItemMatcher
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "isDirectional"(): boolean
public "isFluidModule"(): boolean
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getRenderColor"(arg0: integer): integer
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
get "baseRange"(): integer
get "menuType"(): $MenuType<(any)>
get "directional"(): boolean
get "fluidModule"(): boolean
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidModule2$Type = ($FluidModule2);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidModule2_ = $FluidModule2$Type;
}}
declare module "packages/me/desht/modularrouters/item/upgrade/$StackUpgrade" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$UpgradeItem, $UpgradeItem$Type} from "packages/me/desht/modularrouters/item/upgrade/$UpgradeItem"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $StackUpgrade extends $UpgradeItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getExtraUsageParams"(): (any)[]
public "getStackLimit"(arg0: integer): integer
public "getItemTint"(): $TintColor
get "extraUsageParams"(): (any)[]
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StackUpgrade$Type = ($StackUpgrade);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StackUpgrade_ = $StackUpgrade$Type;
}}
declare module "packages/me/desht/modularrouters/logic/$RouterRedstoneBehaviour" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IHasTranslationKey, $IHasTranslationKey$Type} from "packages/me/desht/modularrouters/client/util/$IHasTranslationKey"

export class $RouterRedstoneBehaviour extends $Enum<($RouterRedstoneBehaviour)> implements $IHasTranslationKey {
static readonly "ALWAYS": $RouterRedstoneBehaviour
static readonly "LOW": $RouterRedstoneBehaviour
static readonly "HIGH": $RouterRedstoneBehaviour
static readonly "NEVER": $RouterRedstoneBehaviour
static readonly "PULSE": $RouterRedstoneBehaviour


public static "values"(): ($RouterRedstoneBehaviour)[]
public static "valueOf"(arg0: string): $RouterRedstoneBehaviour
public "getTranslationKey"(): string
public "shouldRun"(arg0: boolean, arg1: boolean): boolean
public static "forValue"(arg0: string): $RouterRedstoneBehaviour
get "translationKey"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RouterRedstoneBehaviour$Type = (("always") | ("never") | ("high") | ("low") | ("pulse")) | ($RouterRedstoneBehaviour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RouterRedstoneBehaviour_ = $RouterRedstoneBehaviour$Type;
}}
declare module "packages/me/desht/modularrouters/container/$AbstractSmartFilterMenu" {
import {$AbstractMRContainerMenu, $AbstractMRContainerMenu$Type} from "packages/me/desht/modularrouters/container/$AbstractMRContainerMenu"
import {$NonNullList, $NonNullList$Type} from "packages/net/minecraft/core/$NonNullList"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$ModularRouterBlockEntity, $ModularRouterBlockEntity$Type} from "packages/me/desht/modularrouters/block/tile/$ModularRouterBlockEntity"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$List, $List$Type} from "packages/java/util/$List"
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 {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"

export class $AbstractSmartFilterMenu extends $AbstractMRContainerMenu {
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 "getLocator"(): $MFLocator
public "stillValid"(arg0: $Player$Type): boolean
public "getFilterStack"(): $ItemStack
public "getRouter"(): $ModularRouterBlockEntity
get "locator"(): $MFLocator
get "filterStack"(): $ItemStack
get "router"(): $ModularRouterBlockEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $AbstractSmartFilterMenu$Type = ($AbstractSmartFilterMenu);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $AbstractSmartFilterMenu_ = $AbstractSmartFilterMenu$Type;
}}
declare module "packages/me/desht/modularrouters/client/render/area/$IPositionProvider" {
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export interface $IPositionProvider {

 "getRenderColor"(arg0: integer): integer
 "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
}

export namespace $IPositionProvider {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IPositionProvider$Type = ($IPositionProvider);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IPositionProvider_ = $IPositionProvider$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ActivatorModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ActivatorModule extends $ModuleItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "getItemTint"(): $TintColor
get "menuType"(): $MenuType<(any)>
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ActivatorModule$Type = ($ActivatorModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ActivatorModule_ = $ActivatorModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ModuleItem$Termination" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IHasTranslationKey, $IHasTranslationKey$Type} from "packages/me/desht/modularrouters/client/util/$IHasTranslationKey"

export class $ModuleItem$Termination extends $Enum<($ModuleItem$Termination)> implements $IHasTranslationKey {
static readonly "NONE": $ModuleItem$Termination
static readonly "RAN": $ModuleItem$Termination
static readonly "NOT_RAN": $ModuleItem$Termination


public static "values"(): ($ModuleItem$Termination)[]
public static "valueOf"(arg0: string): $ModuleItem$Termination
public "getTranslationKey"(): string
get "translationKey"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModuleItem$Termination$Type = (("not_ran") | ("none") | ("ran")) | ($ModuleItem$Termination);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModuleItem$Termination_ = $ModuleItem$Termination$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$FluidModule1$FluidDirection" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$IHasTranslationKey, $IHasTranslationKey$Type} from "packages/me/desht/modularrouters/client/util/$IHasTranslationKey"

export class $FluidModule1$FluidDirection extends $Enum<($FluidModule1$FluidDirection)> implements $IHasTranslationKey {
static readonly "IN": $FluidModule1$FluidDirection
static readonly "OUT": $FluidModule1$FluidDirection


public static "values"(): ($FluidModule1$FluidDirection)[]
public static "valueOf"(arg0: string): $FluidModule1$FluidDirection
public "getTranslationKey"(): string
get "translationKey"(): string
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $FluidModule1$FluidDirection$Type = (("in") | ("out")) | ($FluidModule1$FluidDirection);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FluidModule1$FluidDirection_ = $FluidModule1$FluidDirection$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$IRangedModule" {
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export interface $IRangedModule {

 "getBaseRange"(): integer
 "getCurrentRange"(arg0: integer): integer
 "getCurrentRange"(arg0: $ItemStack$Type): integer
 "getHardMaxRange"(): integer
}

export namespace $IRangedModule {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IRangedModule$Type = ($IRangedModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IRangedModule_ = $IRangedModule$Type;
}}
declare module "packages/me/desht/modularrouters/logic/$ModuleTarget" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$LazyOptional, $LazyOptional$Type} from "packages/net/minecraftforge/common/util/$LazyOptional"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$GlobalPos, $GlobalPos$Type} from "packages/net/minecraft/core/$GlobalPos"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$IEnergyStorage, $IEnergyStorage$Type} from "packages/net/minecraftforge/energy/$IEnergyStorage"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$IItemHandler, $IItemHandler$Type} from "packages/net/minecraftforge/items/$IItemHandler"

export class $ModuleTarget {
readonly "gPos": $GlobalPos
readonly "face": $Direction
readonly "blockTranslationKey": string

constructor(arg0: $GlobalPos$Type)
constructor(arg0: $GlobalPos$Type, arg1: $Direction$Type)
constructor(arg0: $GlobalPos$Type, arg1: $Direction$Type, arg2: string)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getTextComponent"(): $Component
public "toNBT"(): $CompoundTag
public "getItemHandler"(): $LazyOptional<($IItemHandler)>
public static "fromNBT"(arg0: $CompoundTag$Type): $ModuleTarget
public "getEnergyHandler"(): $LazyOptional<($IEnergyStorage)>
public "isSameWorld"(arg0: $ModuleTarget$Type): boolean
public "isSameWorld"(arg0: $Level$Type): boolean
public "hasItemHandlerClientSide"(): boolean
get "textComponent"(): $Component
get "itemHandler"(): $LazyOptional<($IItemHandler)>
get "energyHandler"(): $LazyOptional<($IEnergyStorage)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModuleTarget$Type = ($ModuleTarget);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModuleTarget_ = $ModuleTarget$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ExtruderModule1" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$IPickaxeUser, $IPickaxeUser$Type} from "packages/me/desht/modularrouters/item/module/$IPickaxeUser"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ExtruderModule1 extends $ModuleItem implements $IRangedModule, $IPickaxeUser {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
public "getPickaxe"(arg0: $ItemStack$Type): $ItemStack
public "setPickaxe"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $ItemStack
get "baseRange"(): integer
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExtruderModule1$Type = ($ExtruderModule1);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExtruderModule1_ = $ExtruderModule1$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ExtruderModule2" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ExtruderModule2 extends $ModuleItem implements $IRangedModule {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExtruderModule2$Type = ($ExtruderModule2);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExtruderModule2_ = $ExtruderModule2$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$ModuleItem$RelativeDirection" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"

export class $ModuleItem$RelativeDirection extends $Enum<($ModuleItem$RelativeDirection)> {
static readonly "NONE": $ModuleItem$RelativeDirection
static readonly "DOWN": $ModuleItem$RelativeDirection
static readonly "UP": $ModuleItem$RelativeDirection
static readonly "LEFT": $ModuleItem$RelativeDirection
static readonly "RIGHT": $ModuleItem$RelativeDirection
static readonly "FRONT": $ModuleItem$RelativeDirection
static readonly "BACK": $ModuleItem$RelativeDirection


public static "values"(): ($ModuleItem$RelativeDirection)[]
public static "valueOf"(arg0: string): $ModuleItem$RelativeDirection
public "getMask"(): integer
public "getSymbol"(): string
public "getTextureY"(): integer
public "getTextureX"(arg0: boolean): integer
public "toAbsolute"(arg0: $Direction$Type): $Direction
get "mask"(): integer
get "symbol"(): string
get "textureY"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModuleItem$RelativeDirection$Type = (("left") | ("back") | ("none") | ("up") | ("right") | ("front") | ("down")) | ($ModuleItem$RelativeDirection);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModuleItem$RelativeDirection_ = $ModuleItem$RelativeDirection$Type;
}}
declare module "packages/me/desht/modularrouters/block/$CamouflageableBlock" {
import {$VoxelShape, $VoxelShape$Type} from "packages/net/minecraft/world/phys/shapes/$VoxelShape"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
import {$CollisionContext, $CollisionContext$Type} from "packages/net/minecraft/world/phys/shapes/$CollisionContext"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$BlockState, $BlockState$Type} from "packages/net/minecraft/world/level/block/state/$BlockState"
import {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$BlockGetter, $BlockGetter$Type} from "packages/net/minecraft/world/level/$BlockGetter"
import {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Explosion, $Explosion$Type} from "packages/net/minecraft/world/level/$Explosion"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$ModelProperty, $ModelProperty$Type} from "packages/net/minecraftforge/client/model/data/$ModelProperty"

export class $CamouflageableBlock extends $Block {
static readonly "CAMOUFLAGE_STATE": $ModelProperty<($BlockState)>
/**
 * 
 * @deprecated
 */
static readonly "BLOCK_STATE_REGISTRY": $IdMapper<($BlockState)>
static readonly "UPDATE_NEIGHBORS": integer
static readonly "UPDATE_CLIENTS": integer
static readonly "UPDATE_INVISIBLE": integer
static readonly "UPDATE_IMMEDIATE": integer
static readonly "UPDATE_KNOWN_SHAPE": integer
static readonly "UPDATE_SUPPRESS_DROPS": integer
static readonly "UPDATE_MOVE_BY_PISTON": integer
static readonly "UPDATE_NONE": integer
static readonly "UPDATE_ALL": integer
static readonly "UPDATE_ALL_IMMEDIATE": integer
static readonly "INDESTRUCTIBLE": float
static readonly "INSTANT": float
static readonly "UPDATE_LIMIT": integer
 "stateDefinition": $StateDefinition<($Block), ($BlockState)>
readonly "properties": $BlockBehaviour$Properties


public "getExplosionResistance"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Explosion$Type): float
public "isSignalSource"(arg0: $BlockState$Type): boolean
public "getOcclusionShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type): $VoxelShape
public "getInteractionShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type): $VoxelShape
public "getCollisionShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
public "getLightBlock"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type): integer
public "getShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
public "getVisualShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
public "getSignal"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Direction$Type): integer
public "getDestroyProgress"(arg0: $BlockState$Type, arg1: $Player$Type, arg2: $BlockGetter$Type, arg3: $BlockPos$Type): float
public "getDirectSignal"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $Direction$Type): integer
public "getLightEmission"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type): integer
public "propagatesSkylightDown"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type): boolean
public "getUncamouflagedShape"(arg0: $BlockState$Type, arg1: $BlockGetter$Type, arg2: $BlockPos$Type, arg3: $CollisionContext$Type): $VoxelShape
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CamouflageableBlock$Type = ($CamouflageableBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CamouflageableBlock_ = $CamouflageableBlock$Type;
}}
declare module "packages/me/desht/modularrouters/network/$GuiSyncMessage" {
import {$NetworkEvent$Context, $NetworkEvent$Context$Type} from "packages/net/minecraftforge/network/$NetworkEvent$Context"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"

export class $GuiSyncMessage {

constructor(arg0: $ItemStack$Type)
constructor(arg0: $FriendlyByteBuf$Type)

public "toBytes"(arg0: $FriendlyByteBuf$Type): void
public "handle"(arg0: $Supplier$Type<($NetworkEvent$Context$Type)>): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $GuiSyncMessage$Type = ($GuiSyncMessage);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $GuiSyncMessage_ = $GuiSyncMessage$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$TagFilter" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$SmartFilterItem, $SmartFilterItem$Type} from "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$TagKey, $TagKey$Type} from "packages/net/minecraft/tags/$TagKey"
import {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$AbstractSmartFilterMenu, $AbstractSmartFilterMenu$Type} from "packages/me/desht/modularrouters/container/$AbstractSmartFilterMenu"

export class $TagFilter extends $SmartFilterItem {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public "createMenu"(arg0: integer, arg1: $Inventory$Type, arg2: $MFLocator$Type): $AbstractSmartFilterMenu
public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
public static "setTagList"(arg0: $ItemStack$Type, arg1: $List$Type<($TagKey$Type<($Item$Type)>)>): void
public static "getTagList"(arg0: $ItemStack$Type): $List<($TagKey<($Item)>)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TagFilter$Type = ($TagFilter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TagFilter_ = $TagFilter$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$VacuumModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$IRangedModule, $IRangedModule$Type} from "packages/me/desht/modularrouters/item/module/$IRangedModule"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $VacuumModule extends $ModuleItem implements $IRangedModule {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getBaseRange"(): integer
public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "isOmniDirectional"(): boolean
public "getItemTint"(): $TintColor
public "getHardMaxRange"(): integer
public "getCurrentRange"(arg0: integer): integer
public "getCurrentRange"(arg0: $ItemStack$Type): integer
get "baseRange"(): integer
get "menuType"(): $MenuType<(any)>
get "omniDirectional"(): boolean
get "itemTint"(): $TintColor
get "hardMaxRange"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $VacuumModule$Type = ($VacuumModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $VacuumModule_ = $VacuumModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/module/$DistributorModule" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$SenderModule2, $SenderModule2$Type} from "packages/me/desht/modularrouters/item/module/$SenderModule2"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$MenuType, $MenuType$Type} from "packages/net/minecraft/world/inventory/$MenuType"
import {$TintColor, $TintColor$Type} from "packages/me/desht/modularrouters/client/util/$TintColor"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$ModuleTarget, $ModuleTarget$Type} from "packages/me/desht/modularrouters/logic/$ModuleTarget"

export class $DistributorModule extends $SenderModule2 {
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "addSettingsInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "getEnergyCost"(arg0: $ItemStack$Type): integer
public "getMenuType"(): $MenuType<(any)>
public "getItemTint"(): $TintColor
public "getRenderColor"(arg0: integer): integer
public "getStoredPositions"(arg0: $ItemStack$Type): $List<($ModuleTarget)>
get "menuType"(): $MenuType<(any)>
get "itemTint"(): $TintColor
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DistributorModule$Type = ($DistributorModule);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DistributorModule_ = $DistributorModule$Type;
}}
declare module "packages/me/desht/modularrouters/item/augment/$PushingAugment" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$ModuleItem, $ModuleItem$Type} from "packages/me/desht/modularrouters/item/module/$ModuleItem"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$AugmentItem, $AugmentItem$Type} from "packages/me/desht/modularrouters/item/augment/$AugmentItem"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $PushingAugment extends $AugmentItem {
static readonly "SLOTS": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "getMaxAugments"(arg0: $ModuleItem$Type): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PushingAugment$Type = ($PushingAugment);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PushingAugment_ = $PushingAugment$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$BulkItemFilter" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$SmartFilterItem, $SmartFilterItem$Type} from "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$InteractionResult, $InteractionResult$Type} from "packages/net/minecraft/world/$InteractionResult"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$UseOnContext, $UseOnContext$Type} from "packages/net/minecraft/world/item/context/$UseOnContext"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$AbstractSmartFilterMenu, $AbstractSmartFilterMenu$Type} from "packages/me/desht/modularrouters/container/$AbstractSmartFilterMenu"

export class $BulkItemFilter extends $SmartFilterItem {
static readonly "FILTER_SIZE": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public "createMenu"(arg0: integer, arg1: $Inventory$Type, arg2: $MFLocator$Type): $AbstractSmartFilterMenu
public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "useOn"(arg0: $UseOnContext$Type): $InteractionResult
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BulkItemFilter$Type = ($BulkItemFilter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BulkItemFilter_ = $BulkItemFilter$Type;
}}
declare module "packages/me/desht/modularrouters/client/util/$TintColor" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export class $TintColor {
static readonly "WHITE": $TintColor
static readonly "BLACK": $TintColor

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

public "getRGB"(): integer
public "getAlpha"(): integer
public "getRed"(): integer
public "getGreen"(): integer
public "getBlue"(): integer
public static "HSBtoRGB"(arg0: float, arg1: float, arg2: float): integer
public "darker"(): $TintColor
public static "RGBtoHSB"(arg0: integer, arg1: integer, arg2: integer, arg3: (float)[]): (float)[]
public static "getHSBColor"(arg0: float, arg1: float, arg2: float): $TintColor
get "rGB"(): integer
get "alpha"(): integer
get "red"(): integer
get "green"(): integer
get "blue"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TintColor$Type = ($TintColor);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TintColor_ = $TintColor$Type;
}}
declare module "packages/me/desht/modularrouters/client/util/$IHasTranslationKey" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $IHasTranslationKey {

 "getTranslationKey"(): string

(): string
}

export namespace $IHasTranslationKey {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IHasTranslationKey$Type = ($IHasTranslationKey);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IHasTranslationKey_ = $IHasTranslationKey$Type;
}}
declare module "packages/me/desht/modularrouters/item/smartfilter/$ModFilter" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$SmartFilterItem, $SmartFilterItem$Type} from "packages/me/desht/modularrouters/item/smartfilter/$SmartFilterItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IItemMatcher, $IItemMatcher$Type} from "packages/me/desht/modularrouters/logic/filter/matchers/$IItemMatcher"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$MFLocator, $MFLocator$Type} from "packages/me/desht/modularrouters/util/$MFLocator"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$List, $List$Type} from "packages/java/util/$List"
import {$FilterSettingsMessage, $FilterSettingsMessage$Type} from "packages/me/desht/modularrouters/network/$FilterSettingsMessage"
import {$GuiSyncMessage, $GuiSyncMessage$Type} from "packages/me/desht/modularrouters/network/$GuiSyncMessage"
import {$Inventory, $Inventory$Type} from "packages/net/minecraft/world/entity/player/$Inventory"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$AbstractSmartFilterMenu, $AbstractSmartFilterMenu$Type} from "packages/me/desht/modularrouters/container/$AbstractSmartFilterMenu"

export class $ModFilter extends $SmartFilterItem {
static readonly "MAX_SIZE": integer
static readonly "BY_BLOCK": $Map<($Block), ($Item)>
static readonly "BASE_ATTACK_DAMAGE_UUID": $UUID
static readonly "BASE_ATTACK_SPEED_UUID": $UUID
static readonly "MAX_STACK_SIZE": integer
static readonly "EAT_DURATION": integer
static readonly "MAX_BAR_WIDTH": integer

constructor()

public "compile"(arg0: $ItemStack$Type, arg1: $ItemStack$Type): $IItemMatcher
public "getSize"(arg0: $ItemStack$Type): integer
public static "getModList"(arg0: $ItemStack$Type): $List<(string)>
public "createMenu"(arg0: integer, arg1: $Inventory$Type, arg2: $MFLocator$Type): $AbstractSmartFilterMenu
public "addExtraInformation"(arg0: $ItemStack$Type, arg1: $List$Type<($Component$Type)>): void
public "onReceiveSettingsMessage"(arg0: $Player$Type, arg1: $FilterSettingsMessage$Type, arg2: $ItemStack$Type, arg3: $ItemStack$Type): $GuiSyncMessage
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ModFilter$Type = ($ModFilter);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ModFilter_ = $ModFilter$Type;
}}
