declare module "packages/ca/teamdman/sfml/ast/$LabelAccess" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$DirectionQualifier, $DirectionQualifier$Type} from "packages/ca/teamdman/sfml/ast/$DirectionQualifier"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$NumberRangeSet, $NumberRangeSet$Type} from "packages/ca/teamdman/sfml/ast/$NumberRangeSet"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$RoundRobin, $RoundRobin$Type} from "packages/ca/teamdman/sfml/ast/$RoundRobin"

export class $LabelAccess extends $Record implements $ASTNode {

constructor(labels: $List$Type<($Label$Type)>, directions: $DirectionQualifier$Type, slots: $NumberRangeSet$Type, roundRobin: $RoundRobin$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "slots"(): $NumberRangeSet
public "labels"(): $List<($Label)>
public "roundRobin"(): $RoundRobin
public "directions"(): $DirectionQualifier
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LabelAccess$Type = ($LabelAccess);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LabelAccess_ = $LabelAccess$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Interval" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $Interval extends $Record implements $ASTNode {

constructor(ticks: integer)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getTicks"(): integer
public "ticks"(): integer
public static "fromTicks"(arg0: integer): $Interval
public static "fromSeconds"(arg0: integer): $Interval
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Interval$Type = ($Interval);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Interval_ = $Interval$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$IOKind" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $SimulateExploreAllPathsProgramBehaviour$IOKind extends $Enum<($SimulateExploreAllPathsProgramBehaviour$IOKind)> {
static readonly "INPUT": $SimulateExploreAllPathsProgramBehaviour$IOKind
static readonly "OUTPUT": $SimulateExploreAllPathsProgramBehaviour$IOKind


public static "values"(): ($SimulateExploreAllPathsProgramBehaviour$IOKind)[]
public static "valueOf"(arg0: string): $SimulateExploreAllPathsProgramBehaviour$IOKind
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$IOKind$Type = (("output") | ("input")) | ($SimulateExploreAllPathsProgramBehaviour$IOKind);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour$IOKind_ = $SimulateExploreAllPathsProgramBehaviour$IOKind$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$PrintingPressBlockItem" {
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 {$BlockItem, $BlockItem$Type} from "packages/net/minecraft/world/item/$BlockItem"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
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 $PrintingPressBlockItem extends $BlockItem {
static readonly "BLOCK_ENTITY_TAG": string
static readonly "BLOCK_STATE_TAG": 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 "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 $PrintingPressBlockItem$Type = ($PrintingPressBlockItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrintingPressBlockItem_ = $PrintingPressBlockItem$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ForgetStatementStatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$StatementContext, $SFMLParser$StatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StatementContext"
import {$SFMLParser$ForgetstatementContext, $SFMLParser$ForgetstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ForgetstatementContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ForgetStatementStatementContext extends $SFMLParser$StatementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$StatementContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "forgetstatement"(): $SFMLParser$ForgetstatementContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ForgetStatementStatementContext$Type = ($SFMLParser$ForgetStatementStatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ForgetStatementStatementContext_ = $SFMLParser$ForgetStatementStatementContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$NetworkToolItem" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
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 {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
import {$UseOnContext, $UseOnContext$Type} from "packages/net/minecraft/world/item/context/$UseOnContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Map, $Map$Type} from "packages/java/util/$Map"
import {$Entity, $Entity$Type} from "packages/net/minecraft/world/entity/$Entity"

export class $NetworkToolItem 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()

public "inventoryTick"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $Entity$Type, arg3: integer, arg4: boolean): void
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public "onItemUseFirst"(arg0: $ItemStack$Type, arg1: $UseOnContext$Type): $InteractionResult
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NetworkToolItem$Type = ($NetworkToolItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NetworkToolItem_ = $NetworkToolItem$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$CableBlock" {
import {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
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 {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$ICableBlock, $ICableBlock$Type} from "packages/ca/teamdman/sfm/common/cablenetwork/$ICableBlock"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"

export class $CableBlock extends $Block implements $ICableBlock {
/**
 * 
 * @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()

public "onPlace"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
public "onRemove"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CableBlock$Type = ($CableBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CableBlock_ = $CableBlock$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourceLimitMovementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$SFMLParser$MovementContext, $SFMLParser$MovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$MovementContext"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$ResourcelimitContext, $SFMLParser$ResourcelimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcelimitContext"

export class $SFMLParser$ResourceLimitMovementContext extends $SFMLParser$MovementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$MovementContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "COMMA"(): $List<($TerminalNode)>
public "COMMA"(arg0: integer): $TerminalNode
public "resourcelimit"(arg0: integer): $SFMLParser$ResourcelimitContext
public "resourcelimit"(): $List<($SFMLParser$ResourcelimitContext)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourceLimitMovementContext$Type = ($SFMLParser$ResourceLimitMovementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourceLimitMovementContext_ = $SFMLParser$ResourceLimitMovementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ResourceidContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$ResourceidContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourceidContext$Type = ($SFMLParser$ResourceidContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourceidContext_ = $SFMLParser$ResourceidContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/recipe/$NotContainer" {
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Ingredient, $Ingredient$Type} from "packages/net/minecraft/world/item/crafting/$Ingredient"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Container, $Container$Type} from "packages/net/minecraft/world/$Container"
import {$BlockContainerJS, $BlockContainerJS$Type} from "packages/dev/latvian/mods/kubejs/level/$BlockContainerJS"

export interface $NotContainer extends $Container {

 "setItem"(arg0: integer, arg1: $ItemStack$Type): void
 "getItem"(arg0: integer): $ItemStack
 "removeItemNoUpdate"(arg0: integer): $ItemStack
 "getContainerSize"(): integer
 "getMaxStackSize"(): integer
 "startOpen"(arg0: $Player$Type): void
 "stopOpen"(arg0: $Player$Type): void
 "stillValid"(arg0: $Player$Type): boolean
 "canPlaceItem"(arg0: integer, arg1: $ItemStack$Type): boolean
 "hasAnyOf"(arg0: $Set$Type<($Item$Type)>): boolean
 "countItem"(arg0: $Item$Type): integer
 "hasAnyMatching"(arg0: $Predicate$Type<($ItemStack$Type)>): boolean
 "setChanged"(): void
 "removeItem"(arg0: integer, arg1: integer): $ItemStack
 "isEmpty"(): boolean
 "clearContent"(): void
 "kjs$self"(): $Container
 "canTakeItem"(arg0: $Container$Type, arg1: integer, arg2: $ItemStack$Type): boolean
 "isMutable"(): boolean
 "extractItem"(slot: integer, amount: integer, simulate: boolean): $ItemStack
 "setStackInSlot"(slot: integer, stack: $ItemStack$Type): void
 "isItemValid"(slot: integer, stack: $ItemStack$Type): boolean
 "insertItem"(slot: integer, stack: $ItemStack$Type, simulate: boolean): $ItemStack
 "getStackInSlot"(slot: integer): $ItemStack
 "getSlotLimit"(slot: integer): integer
 "getSlots"(): integer
 "getHeight"(): integer
 "asContainer"(): $Container
 "setChanged"(): void
 "clear"(): void
 "getWidth"(): integer
 "getBlock"(level: $Level$Type): $BlockContainerJS
 "isEmpty"(): boolean
 "insertItem"(stack: $ItemStack$Type, simulate: boolean): $ItemStack
 "getAllItems"(): $List<($ItemStack)>
 "count"(ingredient: $Ingredient$Type): integer
 "count"(): integer
 "find"(ingredient: $Ingredient$Type): integer
 "find"(): integer
 "countNonEmpty"(ingredient: $Ingredient$Type): integer
 "countNonEmpty"(): integer
 "clear"(ingredient: $Ingredient$Type): void
}

export namespace $NotContainer {
function stillValidBlockEntity(arg0: $BlockEntity$Type, arg1: $Player$Type): boolean
function stillValidBlockEntity(arg0: $BlockEntity$Type, arg1: $Player$Type, arg2: integer): boolean
function tryClear(arg0: any): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NotContainer$Type = ($NotContainer);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NotContainer_ = $NotContainer$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceQuantity$IdExpansionBehaviour" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $ResourceQuantity$IdExpansionBehaviour extends $Enum<($ResourceQuantity$IdExpansionBehaviour)> {
static readonly "EXPAND": $ResourceQuantity$IdExpansionBehaviour
static readonly "NO_EXPAND": $ResourceQuantity$IdExpansionBehaviour


public static "values"(): ($ResourceQuantity$IdExpansionBehaviour)[]
public static "valueOf"(arg0: string): $ResourceQuantity$IdExpansionBehaviour
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceQuantity$IdExpansionBehaviour$Type = (("expand") | ("no_expand")) | ($ResourceQuantity$IdExpansionBehaviour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceQuantity$IdExpansionBehaviour_ = $ResourceQuantity$IdExpansionBehaviour$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$BatteryBlock" {
import {$IntegerProperty, $IntegerProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$IntegerProperty"
import {$EntityBlock, $EntityBlock$Type} from "packages/net/minecraft/world/level/block/$EntityBlock"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
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 {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
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 {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$BlockHitResult, $BlockHitResult$Type} from "packages/net/minecraft/world/phys/$BlockHitResult"
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"

export class $BatteryBlock extends $Block implements $EntityBlock {
static readonly "LEVEL": $IntegerProperty
/**
 * 
 * @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()

public "use"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $Player$Type, arg4: $InteractionHand$Type, arg5: $BlockHitResult$Type): $InteractionResult
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
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 $BatteryBlock$Type = ($BatteryBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BatteryBlock_ = $BatteryBlock$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$LimitedOutputSlot" {
import {$OutputResourceTracker, $OutputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$OutputResourceTracker"
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export class $LimitedOutputSlot<STACK, ITEM, CAP> {
 "type": $ResourceType<(STACK), (ITEM), (CAP)>
 "handler": CAP
 "pos": $BlockPos
 "label": $Label
 "slot": integer
 "freed": boolean
 "tracker": $OutputResourceTracker<(STACK), (ITEM), (CAP)>

constructor(arg0: $Label$Type, arg1: $BlockPos$Type, arg2: $Direction$Type, arg3: integer, arg4: CAP, arg5: $OutputResourceTracker$Type<(STACK), (ITEM), (CAP)>, arg6: STACK)

public "toString"(): string
public "insert"(arg0: STACK, arg1: boolean): STACK
public "init"(arg0: CAP, arg1: $Label$Type, arg2: $BlockPos$Type, arg3: $Direction$Type, arg4: integer, arg5: $OutputResourceTracker$Type<(STACK), (ITEM), (CAP)>, arg6: STACK): void
public "isDone"(): boolean
public "getStackInSlot"(): STACK
get "done"(): boolean
get "stackInSlot"(): STACK
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LimitedOutputSlot$Type<STACK, ITEM, CAP> = ($LimitedOutputSlot<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LimitedOutputSlot_<STACK, ITEM, CAP> = $LimitedOutputSlot$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RangesetContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$RangeContext, $SFMLParser$RangeContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangeContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RangesetContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "range"(arg0: integer): $SFMLParser$RangeContext
public "range"(): $List<($SFMLParser$RangeContext)>
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "COMMA"(arg0: integer): $TerminalNode
public "COMMA"(): $List<($TerminalNode)>
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RangesetContext$Type = ($SFMLParser$RangesetContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RangesetContext_ = $SFMLParser$RangesetContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$StringLabelContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LabelContext, $SFMLParser$LabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$StringLabelContext extends $SFMLParser$LabelContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$LabelContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "string"(): $SFMLParser$StringContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$StringLabelContext$Type = ($SFMLParser$StringLabelContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$StringLabelContext_ = $SFMLParser$StringLabelContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$QuantityLimitContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$QuantityContext, $SFMLParser$QuantityContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LimitContext, $SFMLParser$LimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$QuantityLimitContext extends $SFMLParser$LimitContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$LimitContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "quantity"(): $SFMLParser$QuantityContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$QuantityLimitContext$Type = ($SFMLParser$QuantityLimitContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$QuantityLimitContext_ = $SFMLParser$QuantityLimitContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourcelimitContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$ResourceidContext, $SFMLParser$ResourceidContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LimitContext, $SFMLParser$LimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ResourcelimitContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "limit"(): $SFMLParser$LimitContext
public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "resourceid"(): $SFMLParser$ResourceidContext
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourcelimitContext$Type = ($SFMLParser$ResourcelimitContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourcelimitContext_ = $SFMLParser$ResourcelimitContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceQuantity" {
import {$ResourceQuantity$IdExpansionBehaviour, $ResourceQuantity$IdExpansionBehaviour$Type} from "packages/ca/teamdman/sfml/ast/$ResourceQuantity$IdExpansionBehaviour"
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$Number, $Number$Type} from "packages/ca/teamdman/sfml/ast/$Number"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $ResourceQuantity extends $Record implements $ASTNode {
static readonly "UNSET": $ResourceQuantity
static readonly "MAX_QUANTITY": $ResourceQuantity

constructor(number: $Number$Type, idExpansionBehaviour: $ResourceQuantity$IdExpansionBehaviour$Type)

public "add"(arg0: $ResourceQuantity$Type): $ResourceQuantity
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "number"(): $Number
public "idExpansionBehaviour"(): $ResourceQuantity$IdExpansionBehaviour
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceQuantity$Type = ($ResourceQuantity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceQuantity_ = $ResourceQuantity$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$DirectionQualifier" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$EnumSet, $EnumSet$Type} from "packages/java/util/$EnumSet"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$Side, $Side$Type} from "packages/ca/teamdman/sfml/ast/$Side"

export class $DirectionQualifier extends $Record implements $ASTNode {
static readonly "NULL_DIRECTION": $DirectionQualifier
static readonly "EVERY_DIRECTION": $DirectionQualifier

constructor(directions: $EnumSet$Type<($Direction$Type)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "stream"(): $Stream<($Direction)>
public static "lookup"(arg0: $Side$Type): $Direction
public "directions"(): $EnumSet<($Direction)>
public static "directionToString"(arg0: $Direction$Type): string
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DirectionQualifier$Type = ($DirectionQualifier);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DirectionQualifier_ = $DirectionQualifier$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$IO" {
import {$IOStatement, $IOStatement$Type} from "packages/ca/teamdman/sfml/ast/$IOStatement"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$SimulateExploreAllPathsProgramBehaviour$IOKind, $SimulateExploreAllPathsProgramBehaviour$IOKind$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$IOKind"
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement, $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement"

export class $SimulateExploreAllPathsProgramBehaviour$IO extends $Record implements $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement {

constructor(arg0: $IOStatement$Type)
constructor(statement: $IOStatement$Type, kind: $SimulateExploreAllPathsProgramBehaviour$IOKind$Type, usedResourceTypes: $Set$Type<($ResourceType$Type)>, usedLabels: $Set$Type<($Label$Type)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "kind"(): $SimulateExploreAllPathsProgramBehaviour$IOKind
public "statement"(): $IOStatement
public "usedResourceTypes"(): $Set<($ResourceType)>
public "usedLabels"(): $Set<($Label)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$IO$Type = ($SimulateExploreAllPathsProgramBehaviour$IO);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour$IO_ = $SimulateExploreAllPathsProgramBehaviour$IO$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Statement" {
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export interface $Statement extends $ASTNode {

 "tick"(arg0: $ProgramContext$Type): void
 "getStatements"(): $List<($Statement)>
 "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
 "getDescendantStatements"(): $Stream<($Statement)>

(arg0: $ProgramContext$Type): void
}

export namespace $Statement {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Statement$Type = ($Statement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Statement_ = $Statement$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$OutputResourceTracker" {
import {$ResourceIdSet, $ResourceIdSet$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdSet"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$AtomicLong, $AtomicLong$Type} from "packages/java/util/concurrent/atomic/$AtomicLong"
import {$ResourceLimit, $ResourceLimit$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimit"

export class $OutputResourceTracker<STACK, ITEM, CAP> implements $Predicate<(any)> {

constructor(arg0: $ResourceLimit$Type<(STACK), (ITEM), (CAP)>, arg1: $ResourceIdSet$Type, arg2: $AtomicLong$Type, arg3: $AtomicLong$Type)

public "toString"(): string
public "test"(arg0: any): boolean
public "getLimit"(): $ResourceLimit<(STACK), (ITEM), (CAP)>
public "isDone"(): boolean
public "matchesCapabilityType"(arg0: any): boolean
public "updateRetentionObservation"(arg0: $ResourceType$Type<(STACK), (ITEM), (CAP)>, arg1: STACK): void
public "trackTransfer"(arg0: long): void
public "getMaxTransferable"(): long
public "negate"(): $Predicate<(any)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public static "isEqual"<T>(arg0: any): $Predicate<(any)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
get "limit"(): $ResourceLimit<(STACK), (ITEM), (CAP)>
get "done"(): boolean
get "maxTransferable"(): long
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $OutputResourceTracker$Type<STACK, ITEM, CAP> = ($OutputResourceTracker<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $OutputResourceTracker_<STACK, ITEM, CAP> = $OutputResourceTracker$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfm/common/program/$ProgramBehaviour" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ProgramBehaviour {

 "fork"(): $ProgramBehaviour

(): $ProgramBehaviour
}

export namespace $ProgramBehaviour {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ProgramBehaviour$Type = ($ProgramBehaviour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ProgramBehaviour_ = $ProgramBehaviour$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanTrueContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanTrueContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "TRUE"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanTrueContext$Type = ($SFMLParser$BooleanTrueContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanTrueContext_ = $SFMLParser$BooleanTrueContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$LimitContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$LimitContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$LimitContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$LimitContext$Type = ($SFMLParser$LimitContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$LimitContext_ = $SFMLParser$LimitContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RangeContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RangeContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $List<($SFMLParser$NumberContext)>
public "number"(arg0: integer): $SFMLParser$NumberContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "DASH"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RangeContext$Type = ($SFMLParser$RangeContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RangeContext_ = $SFMLParser$RangeContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$LabelPositionHolder" {
import {$BiConsumer, $BiConsumer$Type} from "packages/java/util/function/$BiConsumer"
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$BiPredicate, $BiPredicate$Type} from "packages/java/util/function/$BiPredicate"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$Collection, $Collection$Type} from "packages/java/util/$Collection"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $LabelPositionHolder {


public "add"(arg0: string, arg1: $BlockPos$Type): $LabelPositionHolder
public "remove"(arg0: $BlockPos$Type): $LabelPositionHolder
public "remove"(arg0: string, arg1: $BlockPos$Type): $LabelPositionHolder
public "get"(): $Map<(string), ($Set<($BlockPos)>)>
public "toString"(): string
public "clear"(): $LabelPositionHolder
public "contains"(arg0: string, arg1: $BlockPos$Type): boolean
public static "from"(arg0: $ItemStack$Type): $LabelPositionHolder
public "addAll"(arg0: string, arg1: $Collection$Type<($BlockPos$Type)>): $LabelPositionHolder
public static "empty"(): $LabelPositionHolder
public "forEach"(arg0: $BiConsumer$Type<(string), ($BlockPos$Type)>): $LabelPositionHolder
public "save"(arg0: $ItemStack$Type): $LabelPositionHolder
public "removeIf"(arg0: $BiPredicate$Type<(string), ($BlockPos$Type)>): $LabelPositionHolder
public "removeIf"(arg0: $Predicate$Type<(string)>): $LabelPositionHolder
public static "purge"(arg0: $ItemStack$Type): void
public "prune"(): $LabelPositionHolder
public "serialize"(): $CompoundTag
public static "deserialize"(arg0: $CompoundTag$Type): $LabelPositionHolder
public "asHoverText"(): $List<($Component)>
public "addReferencedLabel"(arg0: string): $LabelPositionHolder
public "toggle"(arg0: string, arg1: $BlockPos$Type): $LabelPositionHolder
public "getPositions"(arg0: string): $Set<($BlockPos)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LabelPositionHolder$Type = ($LabelPositionHolder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LabelPositionHolder_ = $LabelPositionHolder$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$PrintingPressBlock" {
import {$EntityBlock, $EntityBlock$Type} from "packages/net/minecraft/world/level/block/$EntityBlock"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
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 {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
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 {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$BlockHitResult, $BlockHitResult$Type} from "packages/net/minecraft/world/phys/$BlockHitResult"
import {$BaseEntityBlock, $BaseEntityBlock$Type} from "packages/net/minecraft/world/level/block/$BaseEntityBlock"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$RenderShape, $RenderShape$Type} from "packages/net/minecraft/world/level/block/$RenderShape"

export class $PrintingPressBlock extends $BaseEntityBlock implements $EntityBlock {
/**
 * 
 * @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()

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 "getRenderShape"(arg0: $BlockState$Type): $RenderShape
public "use"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $Player$Type, arg4: $InteractionHand$Type, arg5: $BlockHitResult$Type): $InteractionResult
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PrintingPressBlock$Type = ($PrintingPressBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrintingPressBlock_ = $PrintingPressBlock$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPath" {
import {$SimulateExploreAllPathsProgramBehaviour$Branch, $SimulateExploreAllPathsProgramBehaviour$Branch$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$Branch"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement, $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement"
import {$SimulateExploreAllPathsProgramBehaviour$IO, $SimulateExploreAllPathsProgramBehaviour$IO$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$IO"

export class $SimulateExploreAllPathsProgramBehaviour$ExecutionPath extends $Record {

constructor()
constructor(history: $List$Type<($SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "stream"(): $Stream<($SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement)>
public "fork"(): $SimulateExploreAllPathsProgramBehaviour$ExecutionPath
public "history"(): $List<($SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement)>
public "streamBranches"(): $Stream<($SimulateExploreAllPathsProgramBehaviour$Branch)>
public "streamOutputs"(): $Stream<($SimulateExploreAllPathsProgramBehaviour$IO)>
public "streamInputs"(): $Stream<($SimulateExploreAllPathsProgramBehaviour$IO)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$ExecutionPath$Type = ($SimulateExploreAllPathsProgramBehaviour$ExecutionPath);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour$ExecutionPath_ = $SimulateExploreAllPathsProgramBehaviour$ExecutionPath$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$LabelGunItem" {
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
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 {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
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 {$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 $LabelGunItem 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()

public static "getNextLabel"(arg0: $ItemStack$Type, arg1: integer): string
public static "setActiveLabel"(arg0: $ItemStack$Type, arg1: string): void
public static "getActiveLabel"(arg0: $ItemStack$Type): string
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "getName"(arg0: $ItemStack$Type): $Component
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public "onItemUseFirst"(arg0: $ItemStack$Type, arg1: $UseOnContext$Type): $InteractionResult
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LabelGunItem$Type = ($LabelGunItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LabelGunItem_ = $LabelGunItem$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$SetOpContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$SetOpContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "ONE"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "SOME"(): $TerminalNode
public "EACH"(): $TerminalNode
public "EVERY"(): $TerminalNode
public "LONE"(): $TerminalNode
public "OVERALL"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$SetOpContext$Type = ($SFMLParser$SetOpContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$SetOpContext_ = $SFMLParser$SetOpContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$RoundRobin" {
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$LabelPositionHolder, $LabelPositionHolder$Type} from "packages/ca/teamdman/sfm/common/program/$LabelPositionHolder"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$RoundRobin$Behaviour, $RoundRobin$Behaviour$Type} from "packages/ca/teamdman/sfml/ast/$RoundRobin$Behaviour"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ArrayList, $ArrayList$Type} from "packages/java/util/$ArrayList"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$Pair, $Pair$Type} from "packages/com/mojang/datafixers/util/$Pair"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export class $RoundRobin implements $ASTNode {

constructor(arg0: $RoundRobin$Behaviour$Type)

public "toString"(): string
public "next"(arg0: integer): integer
public "isEnabled"(): boolean
public static "disabled"(): $RoundRobin
public "getPositionsForLabels"(arg0: $LabelAccess$Type, arg1: $LabelPositionHolder$Type): $ArrayList<($Pair<($Label), ($BlockPos)>)>
public "getBehaviour"(): $RoundRobin$Behaviour
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "enabled"(): boolean
get "behaviour"(): $RoundRobin$Behaviour
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RoundRobin$Type = ($RoundRobin);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RoundRobin_ = $RoundRobin$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$SlotqualifierContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$RangesetContext, $SFMLParser$RangesetContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangesetContext"

export class $SFMLParser$SlotqualifierContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "SLOTS"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "rangeset"(): $SFMLParser$RangesetContext
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$SlotqualifierContext$Type = ($SFMLParser$SlotqualifierContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$SlotqualifierContext_ = $SFMLParser$SlotqualifierContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$OutputstatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$OutputmatchersContext, $SFMLParser$OutputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputmatchersContext"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"
import {$SFMLParser$ResourceexclusionContext, $SFMLParser$ResourceexclusionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceexclusionContext"

export class $SFMLParser$OutputstatementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "TO"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "OUTPUT"(): $TerminalNode
public "labelaccess"(): $SFMLParser$LabelaccessContext
public "outputmatchers"(): $SFMLParser$OutputmatchersContext
public "resourceexclusion"(): $SFMLParser$ResourceexclusionContext
public "EACH"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$OutputstatementContext$Type = ($SFMLParser$OutputstatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$OutputstatementContext_ = $SFMLParser$OutputstatementContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType" {
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$IForgeRegistry, $IForgeRegistry$Type} from "packages/net/minecraftforge/registries/$IForgeRegistry"
import {$NumberRangeSet, $NumberRangeSet$Type} from "packages/ca/teamdman/sfml/ast/$NumberRangeSet"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$CapabilityConsumer, $CapabilityConsumer$Type} from "packages/ca/teamdman/sfm/common/program/$CapabilityConsumer"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$Capability, $Capability$Type} from "packages/net/minecraftforge/common/capabilities/$Capability"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"

export class $ResourceType<STACK, ITEM, CAP> {
readonly "CAPABILITY_KIND": $Capability<(CAP)>

constructor(arg0: $Capability$Type<(CAP)>)

public "equals"(arg0: any): boolean
public "hashCode"(): integer
public "extract"(arg0: CAP, arg1: integer, arg2: long, arg3: boolean): STACK
public "insert"(arg0: CAP, arg1: integer, arg2: STACK, arg3: boolean): STACK
public "isEmpty"(arg0: STACK): boolean
public "copy"(arg0: STACK): STACK
public "getItem"(arg0: STACK): ITEM
public "registryKeyExists"(arg0: $ResourceLocation$Type): boolean
public "getSlots"(arg0: CAP): integer
public "getMaxStackSize"(arg0: STACK): long
public "getMaxStackSize"(arg0: CAP, arg1: integer): long
public "getAmount"(arg0: STACK): long
public "getRegistry"(): $IForgeRegistry<(ITEM)>
public "getRegistryKey"(arg0: STACK): $ResourceLocation
public "getStackInSlot"(arg0: CAP, arg1: integer): STACK
public "getEmptyStack"(): STACK
public "forEachCapability"(arg0: $ProgramContext$Type, arg1: $LabelAccess$Type, arg2: $CapabilityConsumer$Type<(CAP)>): void
public "getStacksInSlots"(arg0: CAP, arg1: $NumberRangeSet$Type): $Stream<(STACK)>
public "matchesStackType"(arg0: any): boolean
public "matchesStack"(arg0: $ResourceIdentifier$Type<(STACK), (ITEM), (CAP)>, arg1: any): boolean
public "displayAsCode"(): string
public "withCount"(arg0: STACK, arg1: long): STACK
public "displayAsCapabilityClass"(): string
public "getAmountDifference"(arg0: STACK, arg1: STACK): long
public "matchesCapabilityType"(arg0: any): boolean
get "registry"(): $IForgeRegistry<(ITEM)>
get "emptyStack"(): STACK
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceType$Type<STACK, ITEM, CAP> = ($ResourceType<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceType_<STACK, ITEM, CAP> = $ResourceType$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfm/common/recipe/$PrintingPressRecipe$Serializer" {
import {$JsonObject, $JsonObject$Type} from "packages/com/google/gson/$JsonObject"
import {$RecipeSerializer, $RecipeSerializer$Type} from "packages/net/minecraft/world/item/crafting/$RecipeSerializer"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$PrintingPressRecipe, $PrintingPressRecipe$Type} from "packages/ca/teamdman/sfm/common/recipe/$PrintingPressRecipe"
import {$ICondition$IContext, $ICondition$IContext$Type} from "packages/net/minecraftforge/common/crafting/conditions/$ICondition$IContext"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$Recipe, $Recipe$Type} from "packages/net/minecraft/world/item/crafting/$Recipe"

export class $PrintingPressRecipe$Serializer implements $RecipeSerializer<($PrintingPressRecipe)> {

constructor()

public "fromJson"(arg0: $ResourceLocation$Type, arg1: $JsonObject$Type): $PrintingPressRecipe
public "fromNetwork"(arg0: $ResourceLocation$Type, arg1: $FriendlyByteBuf$Type): $PrintingPressRecipe
public "toNetwork"(arg0: $FriendlyByteBuf$Type, arg1: $PrintingPressRecipe$Type): void
public static "register"<S extends $RecipeSerializer<(T)>, T extends $Recipe<(any)>>(arg0: string, arg1: S): S
public "fromJson"(arg0: $ResourceLocation$Type, arg1: $JsonObject$Type, arg2: $ICondition$IContext$Type): $PrintingPressRecipe
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PrintingPressRecipe$Serializer$Type = ($PrintingPressRecipe$Serializer);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrintingPressRecipe$Serializer_ = $PrintingPressRecipe$Serializer$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$InputStatement" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceLimits, $ResourceLimits$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimits"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$IOStatement, $IOStatement$Type} from "packages/ca/teamdman/sfml/ast/$IOStatement"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$LimitedInputSlot, $LimitedInputSlot$Type} from "packages/ca/teamdman/sfm/common/program/$LimitedInputSlot"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"

export class $InputStatement implements $IOStatement {

constructor(arg0: $LabelAccess$Type, arg1: $ResourceLimits$Type, arg2: boolean)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "each"(): boolean
public "tick"(arg0: $ProgramContext$Type): void
public "freeSlots"(): void
public "labelAccess"(): $LabelAccess
public "toStringPretty"(): string
public "gatherSlots"(arg0: $ProgramContext$Type, arg1: $Consumer$Type<($LimitedInputSlot$Type<(any), (any), (any)>)>): void
public "resourceLimits"(): $ResourceLimits
public "freeSlotsIf"(arg0: $Predicate$Type<($LimitedInputSlot$Type<(any), (any), (any)>)>): void
public "transferSlotsTo"(arg0: $InputStatement$Type): void
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputStatement$Type = ($InputStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputStatement_ = $InputStatement$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$StatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$StatementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$StatementContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$StatementContext$Type = ($SFMLParser$StatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$StatementContext_ = $SFMLParser$StatementContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$FormItem" {
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 {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
import {$IClientItemExtensions, $IClientItemExtensions$Type} from "packages/net/minecraftforge/client/extensions/common/$IClientItemExtensions"
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 $FormItem 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()

public static "getReference"(arg0: $ItemStack$Type): $ItemStack
public "initializeClient"(arg0: $Consumer$Type<($IClientItemExtensions$Type)>): void
public static "getForm"(arg0: $ItemStack$Type): $ItemStack
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 $FormItem$Type = ($FormItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $FormItem_ = $FormItem$Type;
}}
declare module "packages/ca/teamdman/sfm/common/cablenetwork/$CableNetwork" {
import {$LazyOptional, $LazyOptional$Type} from "packages/net/minecraftforge/common/util/$LazyOptional"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$ChunkAccess, $ChunkAccess$Type} from "packages/net/minecraft/world/level/chunk/$ChunkAccess"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$TranslatableLogger, $TranslatableLogger$Type} from "packages/ca/teamdman/sfm/common/logging/$TranslatableLogger"
import {$LongSet, $LongSet$Type} from "packages/it/unimi/dsi/fastutil/longs/$LongSet"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Capability, $Capability$Type} from "packages/net/minecraftforge/common/capabilities/$Capability"

export class $CableNetwork {

constructor(arg0: $Level$Type)

public "toString"(): string
public "isEmpty"(): boolean
public "getCapability"<CAP>(arg0: $Capability$Type<(CAP)>, arg1: $BlockPos$Type, arg2: $Direction$Type, arg3: $TranslatableLogger$Type): $LazyOptional<(CAP)>
public "getLevel"(): $Level
public "getCablePositions"(): $Stream<($BlockPos)>
public static "isCable"(arg0: $Level$Type, arg1: $BlockPos$Type): boolean
public "mergeNetwork"(arg0: $CableNetwork$Type): void
public "rebuildNetwork"(arg0: $BlockPos$Type): void
public "bustCacheForChunk"(arg0: $ChunkAccess$Type): void
public "addCable"(arg0: $BlockPos$Type): void
public "getCapabilityProviderPositions"(): $Stream<($BlockPos)>
public "getCablePositionsRaw"(): $LongSet
public "containsCablePosition"(arg0: $BlockPos$Type): boolean
public "rebuildNetworkFromCache"(arg0: $BlockPos$Type, arg1: $CableNetwork$Type): void
public "getCableCount"(): integer
public "discoverCables"(arg0: $BlockPos$Type): $Stream<($BlockPos)>
public "isAdjacentToCable"(arg0: $BlockPos$Type): boolean
get "empty"(): boolean
get "level"(): $Level
get "cablePositions"(): $Stream<($BlockPos)>
get "capabilityProviderPositions"(): $Stream<($BlockPos)>
get "cablePositionsRaw"(): $LongSet
get "cableCount"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CableNetwork$Type = ($CableNetwork);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CableNetwork_ = $CableNetwork$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$NumberRangeSet" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$NumberRange, $NumberRange$Type} from "packages/ca/teamdman/sfml/ast/$NumberRange"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $NumberRangeSet extends $Record implements $ASTNode {
static readonly "MAX_RANGE": $NumberRangeSet

constructor(ranges: ($NumberRange$Type)[])

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "contains"(arg0: integer): boolean
public "ranges"(): ($NumberRange)[]
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NumberRangeSet$Type = ($NumberRangeSet);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NumberRangeSet_ = $NumberRangeSet$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RetentionContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RetentionContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "RETAIN"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "EACH"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RetentionContext$Type = ($SFMLParser$RetentionContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RetentionContext_ = $SFMLParser$RetentionContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$IfStatementStatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$StatementContext, $SFMLParser$StatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StatementContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$IfstatementContext, $SFMLParser$IfstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IfstatementContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$IfStatementStatementContext extends $SFMLParser$StatementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$StatementContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "ifstatement"(): $SFMLParser$IfstatementContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$IfStatementStatementContext$Type = ($SFMLParser$IfStatementStatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$IfStatementStatementContext_ = $SFMLParser$IfStatementStatementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$PulseTriggerContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$BlockContext, $SFMLParser$BlockContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BlockContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$TriggerContext, $SFMLParser$TriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TriggerContext"

export class $SFMLParser$PulseTriggerContext extends $SFMLParser$TriggerContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$TriggerContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "block"(): $SFMLParser$BlockContext
public "END"(): $TerminalNode
public "DO"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "REDSTONE"(): $TerminalNode
public "PULSE"(): $TerminalNode
public "EVERY"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$PulseTriggerContext$Type = ($SFMLParser$PulseTriggerContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$PulseTriggerContext_ = $SFMLParser$PulseTriggerContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Program" {
import {$Trigger, $Trigger$Type} from "packages/ca/teamdman/sfml/ast/$Trigger"
import {$TranslatableContents, $TranslatableContents$Type} from "packages/net/minecraft/network/chat/contents/$TranslatableContents"
import {$ASTBuilder, $ASTBuilder$Type} from "packages/ca/teamdman/sfml/ast/$ASTBuilder"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$Function, $Function$Type} from "packages/java/util/function/$Function"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$ManagerBlockEntity, $ManagerBlockEntity$Type} from "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity"
import {$IfStatement, $IfStatement$Type} from "packages/ca/teamdman/sfml/ast/$IfStatement"
import {$OutputStatement, $OutputStatement$Type} from "packages/ca/teamdman/sfml/ast/$OutputStatement"

export class $Program extends $Record implements $Statement {
static readonly "MAX_PROGRAM_LENGTH": integer
static readonly "MAX_LABEL_LENGTH": integer

constructor(builder: $ASTBuilder$Type, name: string, triggers: $List$Type<($Trigger$Type)>, referencedLabels: $Set$Type<(string)>, referencedResources: $Set$Type<($ResourceIdentifier$Type<(any), (any), (any)>)>)

public "name"(): string
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public static "compile"(arg0: string, arg1: $Consumer$Type<($Program$Type)>, arg2: $Consumer$Type<($List$Type<($TranslatableContents$Type)>)>): void
public "builder"(): $ASTBuilder
public "tick"(arg0: $ManagerBlockEntity$Type): boolean
public "tick"(arg0: $ProgramContext$Type): void
public "getStatements"(): $List<($Statement)>
public "triggers"(): $List<($Trigger)>
public "referencedLabels"(): $Set<(string)>
public "replaceOutputStatement"(arg0: $OutputStatement$Type, arg1: $OutputStatement$Type): void
public "referencedResources"(): $Set<($ResourceIdentifier<(any), (any), (any)>)>
public "replaceAllOutputStatements"(arg0: $Function$Type<($OutputStatement$Type), ($OutputStatement$Type)>): void
public "getConditionIndex"(arg0: $IfStatement$Type): integer
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Program$Type = ($Program);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Program_ = $Program$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$TriggerContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$TriggerContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$TriggerContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$TriggerContext$Type = ($SFMLParser$TriggerContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$TriggerContext_ = $SFMLParser$TriggerContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$NumberContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$NumberContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "NUMBER"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$NumberContext$Type = ($SFMLParser$NumberContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$NumberContext_ = $SFMLParser$NumberContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanDisjunctionContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanDisjunctionContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "OR"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "boolexpr"(arg0: integer): $SFMLParser$BoolexprContext
public "boolexpr"(): $List<($SFMLParser$BoolexprContext)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanDisjunctionContext$Type = ($SFMLParser$BooleanDisjunctionContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanDisjunctionContext_ = $SFMLParser$BooleanDisjunctionContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$TestBarrelBlock" {
import {$BarrelBlock, $BarrelBlock$Type} from "packages/net/minecraft/world/level/block/$BarrelBlock"
import {$BooleanProperty, $BooleanProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$BooleanProperty"
import {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
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 {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
import {$DirectionProperty, $DirectionProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$DirectionProperty"

export class $TestBarrelBlock extends $BarrelBlock {
static readonly "FACING": $DirectionProperty
static readonly "OPEN": $BooleanProperty
/**
 * 
 * @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()

public "onRemove"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TestBarrelBlock$Type = ($TestBarrelBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TestBarrelBlock_ = $TestBarrelBlock$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$ManagerBlock" {
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 {$BlockBehaviour$Properties, $BlockBehaviour$Properties$Type} from "packages/net/minecraft/world/level/block/state/$BlockBehaviour$Properties"
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 {$IdMapper, $IdMapper$Type} from "packages/net/minecraft/core/$IdMapper"
import {$ICableBlock, $ICableBlock$Type} from "packages/ca/teamdman/sfm/common/cablenetwork/$ICableBlock"
import {$Block, $Block$Type} from "packages/net/minecraft/world/level/block/$Block"
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 {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$BlockHitResult, $BlockHitResult$Type} from "packages/net/minecraft/world/phys/$BlockHitResult"
import {$BaseEntityBlock, $BaseEntityBlock$Type} from "packages/net/minecraft/world/level/block/$BaseEntityBlock"
import {$BlockEntityTicker, $BlockEntityTicker$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntityTicker"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$RenderShape, $RenderShape$Type} from "packages/net/minecraft/world/level/block/$RenderShape"

export class $ManagerBlock extends $BaseEntityBlock implements $EntityBlock, $ICableBlock {
static readonly "TRIGGERED": $BooleanProperty
/**
 * 
 * @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()

public "onPlace"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
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 "getRenderShape"(arg0: $BlockState$Type): $RenderShape
public "use"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $Player$Type, arg4: $InteractionHand$Type, arg5: $BlockHitResult$Type): $InteractionResult
public "getTicker"<T extends $BlockEntity>(arg0: $Level$Type, arg1: $BlockState$Type, arg2: $BlockEntityType$Type<(T)>): $BlockEntityTicker<(T)>
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ManagerBlock$Type = ($ManagerBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ManagerBlock_ = $ManagerBlock$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$LabelContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$LabelContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$LabelContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$LabelContext$Type = ($SFMLParser$LabelContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$LabelContext_ = $SFMLParser$LabelContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$OutputStatement" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceLimits, $ResourceLimits$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimits"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$IOStatement, $IOStatement$Type} from "packages/ca/teamdman/sfml/ast/$IOStatement"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$LimitedOutputSlot, $LimitedOutputSlot$Type} from "packages/ca/teamdman/sfm/common/program/$LimitedOutputSlot"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$LimitedInputSlot, $LimitedInputSlot$Type} from "packages/ca/teamdman/sfm/common/program/$LimitedInputSlot"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"

export class $OutputStatement implements $IOStatement {

constructor(arg0: $LabelAccess$Type, arg1: $ResourceLimits$Type, arg2: boolean)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "each"(): boolean
public "tick"(arg0: $ProgramContext$Type): void
public "labelAccess"(): $LabelAccess
public static "moveTo"<STACK, ITEM, CAP>(arg0: $ProgramContext$Type, arg1: $LimitedInputSlot$Type<(STACK), (ITEM), (CAP)>, arg2: $LimitedOutputSlot$Type<(STACK), (ITEM), (CAP)>): void
public "toStringPretty"(): string
public "gatherSlots"(arg0: $ProgramContext$Type, arg1: $Consumer$Type<($LimitedOutputSlot$Type<(any), (any), (any)>)>): void
public "resourceLimits"(): $ResourceLimits
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $OutputStatement$Type = ($OutputStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $OutputStatement_ = $OutputStatement$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$TicksContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$IntervalContext, $SFMLParser$IntervalContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IntervalContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$TicksContext extends $SFMLParser$IntervalContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$IntervalContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "TICKS"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$TicksContext$Type = ($SFMLParser$TicksContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$TicksContext_ = $SFMLParser$TicksContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanHasContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$ResourcecomparisonContext, $SFMLParser$ResourcecomparisonContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcecomparisonContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$SetOpContext, $SFMLParser$SetOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SetOpContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"

export class $SFMLParser$BooleanHasContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "setOp"(): $SFMLParser$SetOpContext
public "resourcecomparison"(): $SFMLParser$ResourcecomparisonContext
public "labelaccess"(): $SFMLParser$LabelaccessContext
public "HAS"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanHasContext$Type = ($SFMLParser$BooleanHasContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanHasContext_ = $SFMLParser$BooleanHasContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanNegationContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanNegationContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "NOT"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "boolexpr"(): $SFMLParser$BoolexprContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanNegationContext$Type = ($SFMLParser$BooleanNegationContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanNegationContext_ = $SFMLParser$BooleanNegationContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$ExperienceGoop" {
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 {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ExperienceGoop 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()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExperienceGoop$Type = ($ExperienceGoop);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExperienceGoop_ = $ExperienceGoop$Type;
}}
declare module "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity$State" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$Constants$LocalizationKeys$LocalizationEntry, $Constants$LocalizationKeys$LocalizationEntry$Type} from "packages/ca/teamdman/sfm/common/$Constants$LocalizationKeys$LocalizationEntry"
import {$ChatFormatting, $ChatFormatting$Type} from "packages/net/minecraft/$ChatFormatting"

export class $ManagerBlockEntity$State extends $Enum<($ManagerBlockEntity$State)> {
static readonly "NO_PROGRAM": $ManagerBlockEntity$State
static readonly "NO_DISK": $ManagerBlockEntity$State
static readonly "RUNNING": $ManagerBlockEntity$State
static readonly "INVALID_PROGRAM": $ManagerBlockEntity$State
readonly "COLOR": $ChatFormatting
readonly "LOC": $Constants$LocalizationKeys$LocalizationEntry


public static "values"(): ($ManagerBlockEntity$State)[]
public static "valueOf"(arg0: string): $ManagerBlockEntity$State
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ManagerBlockEntity$State$Type = (("running") | ("invalid_program") | ("no_disk") | ("no_program")) | ($ManagerBlockEntity$State);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ManagerBlockEntity$State_ = $ManagerBlockEntity$State$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Trigger" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Block, $Block$Type} from "packages/ca/teamdman/sfml/ast/$Block"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$IfStatement, $IfStatement$Type} from "packages/ca/teamdman/sfml/ast/$IfStatement"

export interface $Trigger extends $Statement {

 "getBlock"(): $Block
 "getStatements"(): $List<($Statement)>
 "shouldTick"(arg0: $ProgramContext$Type): boolean
 "getConditionIndex"(arg0: $IfStatement$Type): integer
 "getConditionCount"(): integer
 "tick"(arg0: $ProgramContext$Type): void
 "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
 "getDescendantStatements"(): $Stream<($Statement)>
}

export namespace $Trigger {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Trigger$Type = ($Trigger);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Trigger_ = $Trigger$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$BoolExpr" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $BoolExpr extends $Record implements $Predicate<($ProgramContext)>, $ASTNode {

constructor(pred: $Predicate$Type<($ProgramContext$Type)>, sourceCode: string)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: $ProgramContext$Type): boolean
public "pred"(): $Predicate<($ProgramContext)>
public "sourceCode"(): string
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<($ProgramContext)>
public static "isEqual"<T>(arg0: any): $Predicate<($ProgramContext)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<($ProgramContext)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<($ProgramContext)>
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $BoolExpr$Type = ($BoolExpr);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $BoolExpr_ = $BoolExpr$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$SetOperator" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$BiPredicate, $BiPredicate$Type} from "packages/java/util/function/$BiPredicate"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $SetOperator extends $Enum<($SetOperator)> implements $ASTNode, $BiPredicate<(boolean), ($List<(boolean)>)> {
static readonly "OVERALL": $SetOperator
static readonly "SOME": $SetOperator
static readonly "EVERY": $SetOperator
static readonly "ONE": $SetOperator
static readonly "LONE": $SetOperator


public static "values"(): ($SetOperator)[]
public "test"(arg0: boolean, arg1: $List$Type<(boolean)>): boolean
public static "valueOf"(arg0: string): $SetOperator
public static "from"(arg0: string): $SetOperator
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
public "negate"(): $BiPredicate<(boolean), ($List<(boolean)>)>
public "and"(arg0: $BiPredicate$Type<(any), (any)>): $BiPredicate<(boolean), ($List<(boolean)>)>
public "or"(arg0: $BiPredicate$Type<(any), (any)>): $BiPredicate<(boolean), ($List<(boolean)>)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SetOperator$Type = (("some") | ("one") | ("lone") | ("overall") | ("every")) | ($SetOperator);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SetOperator_ = $SetOperator$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$ExperienceShard" {
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 {$Map, $Map$Type} from "packages/java/util/$Map"

export class $ExperienceShard 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()

}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ExperienceShard$Type = ($ExperienceShard);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ExperienceShard_ = $ExperienceShard$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$TickContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$IntervalContext, $SFMLParser$IntervalContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IntervalContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$TickContext extends $SFMLParser$IntervalContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$IntervalContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "TICK"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$TickContext$Type = ($SFMLParser$TickContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$TickContext_ = $SFMLParser$TickContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceIdSet" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$LinkedHashSet, $LinkedHashSet$Type} from "packages/java/util/$LinkedHashSet"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Collection, $Collection$Type} from "packages/java/util/$Collection"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $ResourceIdSet extends $Record implements $ASTNode, $Predicate<(any)> {
static readonly "EMPTY": $ResourceIdSet

constructor(arg0: $Collection$Type<($ResourceIdentifier$Type<(any), (any), (any)>)>)
constructor(resourceIds: $LinkedHashSet$Type<($ResourceIdentifier$Type<(any), (any), (any)>)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: any): boolean
public "resourceIds"(): $LinkedHashSet<($ResourceIdentifier<(any), (any), (any)>)>
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
public "negate"(): $Predicate<(any)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public static "isEqual"<T>(arg0: any): $Predicate<(any)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceIdSet$Type = ($ResourceIdSet);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceIdSet_ = $ResourceIdSet$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$SideContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$SideContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "TOP"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "NORTH"(): $TerminalNode
public "SOUTH"(): $TerminalNode
public "EAST"(): $TerminalNode
public "WEST"(): $TerminalNode
public "BOTTOM"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$SideContext$Type = ($SFMLParser$SideContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$SideContext_ = $SFMLParser$SideContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$SidequalifierContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$SidequalifierContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$SidequalifierContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$SidequalifierContext$Type = ($SFMLParser$SidequalifierContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$SidequalifierContext_ = $SFMLParser$SidequalifierContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$SlotqualifierContext, $SFMLParser$SlotqualifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SlotqualifierContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$SidequalifierContext, $SFMLParser$SidequalifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SidequalifierContext"
import {$SFMLParser$RoundrobinContext, $SFMLParser$RoundrobinContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RoundrobinContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LabelContext, $SFMLParser$LabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelContext"

export class $SFMLParser$LabelaccessContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "label"(): $List<($SFMLParser$LabelContext)>
public "label"(arg0: integer): $SFMLParser$LabelContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "COMMA"(arg0: integer): $TerminalNode
public "COMMA"(): $List<($TerminalNode)>
public "roundrobin"(): $SFMLParser$RoundrobinContext
public "slotqualifier"(): $SFMLParser$SlotqualifierContext
public "sidequalifier"(): $SFMLParser$SidequalifierContext
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$LabelaccessContext$Type = ($SFMLParser$LabelaccessContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$LabelaccessContext_ = $SFMLParser$LabelaccessContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$EachSideContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$SidequalifierContext, $SFMLParser$SidequalifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SidequalifierContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$EachSideContext extends $SFMLParser$SidequalifierContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$SidequalifierContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "SIDE"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "EACH"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$EachSideContext$Type = ($SFMLParser$EachSideContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$EachSideContext_ = $SFMLParser$EachSideContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanConjunctionContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanConjunctionContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "AND"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "boolexpr"(arg0: integer): $SFMLParser$BoolexprContext
public "boolexpr"(): $List<($SFMLParser$BoolexprContext)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanConjunctionContext$Type = ($SFMLParser$BooleanConjunctionContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanConjunctionContext_ = $SFMLParser$BooleanConjunctionContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ProgramContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NameContext, $SFMLParser$NameContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NameContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$TriggerContext, $SFMLParser$TriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TriggerContext"

export class $SFMLParser$ProgramContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "name"(): $SFMLParser$NameContext
public "trigger"(arg0: integer): $SFMLParser$TriggerContext
public "trigger"(): $List<($SFMLParser$TriggerContext)>
public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "EOF"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ProgramContext$Type = ($SFMLParser$ProgramContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ProgramContext_ = $SFMLParser$ProgramContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanRedstoneContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$ComparisonOpContext, $SFMLParser$ComparisonOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$List, $List$Type} from "packages/java/util/$List"

export class $SFMLParser$BooleanRedstoneContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "REDSTONE"(): $TerminalNode
public "comparisonOp"(): $SFMLParser$ComparisonOpContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanRedstoneContext$Type = ($SFMLParser$BooleanRedstoneContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanRedstoneContext_ = $SFMLParser$BooleanRedstoneContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourceContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$ResourceidContext, $SFMLParser$ResourceidContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ResourceContext extends $SFMLParser$ResourceidContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$ResourceidContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "COLON"(): $List<($TerminalNode)>
public "COLON"(arg0: integer): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "REDSTONE"(arg0: integer): $TerminalNode
public "REDSTONE"(): $List<($TerminalNode)>
public "IDENTIFIER"(arg0: integer): $TerminalNode
public "IDENTIFIER"(): $List<($TerminalNode)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourceContext$Type = ($SFMLParser$ResourceContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourceContext_ = $SFMLParser$ResourceContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$LimitedInputSlot" {
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$InputResourceTracker, $InputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$InputResourceTracker"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export class $LimitedInputSlot<STACK, ITEM, CAP> {
 "type": $ResourceType<(STACK), (ITEM), (CAP)>
 "handler": CAP
 "pos": $BlockPos
 "label": $Label
 "direction": $Direction
 "slot": integer
 "freed": boolean
 "tracker": $InputResourceTracker<(STACK), (ITEM), (CAP)>

constructor(arg0: $Label$Type, arg1: $BlockPos$Type, arg2: $Direction$Type, arg3: integer, arg4: CAP, arg5: $InputResourceTracker$Type<(STACK), (ITEM), (CAP)>, arg6: STACK)

public "toString"(): string
public "extract"(arg0: long): STACK
public "init"(arg0: CAP, arg1: $Label$Type, arg2: $BlockPos$Type, arg3: $Direction$Type, arg4: integer, arg5: $InputResourceTracker$Type<(STACK), (ITEM), (CAP)>, arg6: STACK): void
public "setDone"(): void
public "isDone"(): boolean
public "peekExtractPotential"(): STACK
get "done"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $LimitedInputSlot$Type<STACK, ITEM, CAP> = ($LimitedInputSlot<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $LimitedInputSlot_<STACK, ITEM, CAP> = $LimitedInputSlot$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/ast/$Label" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $Label extends $Record implements $ASTNode {

constructor(name: string)

public "name"(): string
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Label$Type = ($Label);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Label_ = $Label$Type;
}}
declare module "packages/ca/teamdman/sfm/common/$Constants$LocalizationKeys$LocalizationEntry" {
import {$TranslatableContents, $TranslatableContents$Type} from "packages/net/minecraft/network/chat/contents/$TranslatableContents"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Supplier, $Supplier$Type} from "packages/java/util/function/$Supplier"
import {$MutableComponent, $MutableComponent$Type} from "packages/net/minecraft/network/chat/$MutableComponent"

export class $Constants$LocalizationKeys$LocalizationEntry extends $Record {

constructor(arg0: string, arg1: string)
constructor(key: $Supplier$Type<(string)>, value: $Supplier$Type<(string)>)

public "get"(): $TranslatableContents
public "get"(...arg0: (any)[]): $TranslatableContents
public "value"(): $Supplier<(string)>
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "key"(): $Supplier<(string)>
public "getString"(): string
public "getString"(...arg0: (any)[]): string
public "getComponent"(): $MutableComponent
public "getComponent"(...arg0: (any)[]): $MutableComponent
get "string"(): string
get "component"(): $MutableComponent
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Constants$LocalizationKeys$LocalizationEntry$Type = ($Constants$LocalizationKeys$LocalizationEntry);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Constants$LocalizationKeys$LocalizationEntry_ = $Constants$LocalizationKeys$LocalizationEntry$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$QuantityRetentionLimitContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$QuantityContext, $SFMLParser$QuantityContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LimitContext, $SFMLParser$LimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitContext"
import {$SFMLParser$RetentionContext, $SFMLParser$RetentionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$QuantityRetentionLimitContext extends $SFMLParser$LimitContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$LimitContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "retention"(): $SFMLParser$RetentionContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "quantity"(): $SFMLParser$QuantityContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$QuantityRetentionLimitContext$Type = ($SFMLParser$QuantityRetentionLimitContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$QuantityRetentionLimitContext_ = $SFMLParser$QuantityRetentionLimitContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement {

}

export namespace $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type = ($SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement_ = $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$StringResourceContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$ResourceidContext, $SFMLParser$ResourceidContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$StringResourceContext extends $SFMLParser$ResourceidContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$ResourceidContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "string"(): $SFMLParser$StringContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$StringResourceContext$Type = ($SFMLParser$StringResourceContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$StringResourceContext_ = $SFMLParser$StringResourceContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$Branch" {
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement, $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement"
import {$IfStatement, $IfStatement$Type} from "packages/ca/teamdman/sfml/ast/$IfStatement"

export class $SimulateExploreAllPathsProgramBehaviour$Branch extends $Record implements $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement {

constructor(ifStatement: $IfStatement$Type, wasTrue: boolean)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "ifStatement"(): $IfStatement
public "wasTrue"(): boolean
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$Branch$Type = ($SimulateExploreAllPathsProgramBehaviour$Branch);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour$Branch_ = $SimulateExploreAllPathsProgramBehaviour$Branch$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$IOStatement" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceLimits, $ResourceLimits$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimits"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"
import {$PrettyStatement, $PrettyStatement$Type} from "packages/ca/teamdman/sfml/ast/$PrettyStatement"

export interface $IOStatement extends $Statement, $PrettyStatement {

 "each"(): boolean
 "labelAccess"(): $LabelAccess
 "resourceLimits"(): $ResourceLimits
 "tick"(arg0: $ProgramContext$Type): void
 "toStringPretty"(): string
 "getStatements"(): $List<($Statement)>
 "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
 "getDescendantStatements"(): $Stream<($Statement)>
}

export namespace $IOStatement {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IOStatement$Type = ($IOStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IOStatement_ = $IOStatement$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour" {
import {$Trigger, $Trigger$Type} from "packages/ca/teamdman/sfml/ast/$Trigger"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$ProgramBehaviour, $ProgramBehaviour$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramBehaviour"
import {$SimulateExploreAllPathsProgramBehaviour$ExecutionPath, $SimulateExploreAllPathsProgramBehaviour$ExecutionPath$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPath"
import {$AtomicReference, $AtomicReference$Type} from "packages/java/util/concurrent/atomic/$AtomicReference"
import {$InputStatement, $InputStatement$Type} from "packages/ca/teamdman/sfml/ast/$InputStatement"
import {$Program, $Program$Type} from "packages/ca/teamdman/sfml/ast/$Program"
import {$BigInteger, $BigInteger$Type} from "packages/java/math/$BigInteger"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement, $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement"
import {$OutputStatement, $OutputStatement$Type} from "packages/ca/teamdman/sfml/ast/$OutputStatement"

export class $SimulateExploreAllPathsProgramBehaviour implements $ProgramBehaviour {

constructor()
constructor(arg0: $List$Type<($SimulateExploreAllPathsProgramBehaviour$ExecutionPath$Type)>, arg1: $SimulateExploreAllPathsProgramBehaviour$ExecutionPath$Type, arg2: $AtomicReference$Type<($BigInteger$Type)>)

public "fork"(): $ProgramBehaviour
public "onOutputStatementExecution"(arg0: $ProgramContext$Type, arg1: $OutputStatement$Type): void
public "getCurrentPath"(): $SimulateExploreAllPathsProgramBehaviour$ExecutionPath
public "pushPathElement"(arg0: $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement$Type): void
public "getSeenPaths"(): $List<($SimulateExploreAllPathsProgramBehaviour$ExecutionPath)>
public "prepareNextTrigger"(): void
public "onTriggerDropped"(arg0: $ProgramContext$Type, arg1: $Trigger$Type): void
public "onProgramFinished"(arg0: $ProgramContext$Type, arg1: $Program$Type): void
public "getPathElementForNode"(arg0: $ASTNode$Type): $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement
public "onInputStatementDropped"(arg0: $ProgramContext$Type, arg1: $InputStatement$Type): void
public "onInputStatementExecution"(arg0: $ProgramContext$Type, arg1: $InputStatement$Type): void
public "terminatePathAndBeginAnew"(): void
public "getTriggerPathCount"(): $BigInteger
public "onInputStatementForgetTransform"(arg0: $ProgramContext$Type, arg1: $InputStatement$Type, arg2: $InputStatement$Type): void
public "getLatestPathElement"(): $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement
public "getSeenIOStatementCountForEachPath"(): (integer)[]
get "currentPath"(): $SimulateExploreAllPathsProgramBehaviour$ExecutionPath
get "seenPaths"(): $List<($SimulateExploreAllPathsProgramBehaviour$ExecutionPath)>
get "triggerPathCount"(): $BigInteger
get "latestPathElement"(): $SimulateExploreAllPathsProgramBehaviour$ExecutionPathElement
get "seenIOStatementCountForEachPath"(): (integer)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SimulateExploreAllPathsProgramBehaviour$Type = ($SimulateExploreAllPathsProgramBehaviour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SimulateExploreAllPathsProgramBehaviour_ = $SimulateExploreAllPathsProgramBehaviour$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$NameContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$NameContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "string"(): $SFMLParser$StringContext
public "NAME"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$NameContext$Type = ($SFMLParser$NameContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$NameContext_ = $SFMLParser$NameContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$QuantityContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "EACH"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$QuantityContext$Type = ($SFMLParser$QuantityContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$QuantityContext_ = $SFMLParser$QuantityContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLBaseVisitor" {
import {$SFMLParser$SideContext, $SFMLParser$SideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SideContext"
import {$SFMLParser$InputStatementStatementContext, $SFMLParser$InputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputStatementStatementContext"
import {$SFMLParser$ResourceContext, $SFMLParser$ResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceContext"
import {$SFMLParser$ResourcelimitContext, $SFMLParser$ResourcelimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcelimitContext"
import {$SFMLParser$BlockContext, $SFMLParser$BlockContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BlockContext"
import {$SFMLParser$RoundrobinContext, $SFMLParser$RoundrobinContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RoundrobinContext"
import {$SFMLParser$StringLabelContext, $SFMLParser$StringLabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringLabelContext"
import {$SFMLParser$ForgetstatementContext, $SFMLParser$ForgetstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ForgetstatementContext"
import {$SFMLParser$RawLabelContext, $SFMLParser$RawLabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RawLabelContext"
import {$SFMLParser$ResourceexclusionContext, $SFMLParser$ResourceexclusionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceexclusionContext"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"
import {$SFMLParser$TicksContext, $SFMLParser$TicksContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TicksContext"
import {$SFMLParser$QuantityLimitContext, $SFMLParser$QuantityLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityLimitContext"
import {$SFMLParser$QuantityRetentionLimitContext, $SFMLParser$QuantityRetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityRetentionLimitContext"
import {$SFMLParser$QuantityContext, $SFMLParser$QuantityContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext"
import {$SFMLParser$TickContext, $SFMLParser$TickContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TickContext"
import {$SFMLParser$InputmatchersContext, $SFMLParser$InputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputmatchersContext"
import {$SFMLParser$BooleanParenContext, $SFMLParser$BooleanParenContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanParenContext"
import {$SFMLParser$IfStatementStatementContext, $SFMLParser$IfStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IfStatementStatementContext"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$SFMLParser$EachSideContext, $SFMLParser$EachSideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$EachSideContext"
import {$SFMLParser$NameContext, $SFMLParser$NameContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NameContext"
import {$SFMLParser$SetOpContext, $SFMLParser$SetOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SetOpContext"
import {$SFMLParser$RetentionLimitContext, $SFMLParser$RetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionLimitContext"
import {$SFMLParser$OutputmatchersContext, $SFMLParser$OutputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputmatchersContext"
import {$SFMLParser$RetentionContext, $SFMLParser$RetentionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionContext"
import {$SFMLParser$ForgetStatementStatementContext, $SFMLParser$ForgetStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ForgetStatementStatementContext"
import {$SFMLParser$PulseTriggerContext, $SFMLParser$PulseTriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$PulseTriggerContext"
import {$SFMLParser$ResourceLimitMovementContext, $SFMLParser$ResourceLimitMovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceLimitMovementContext"
import {$SFMLParser$BooleanNegationContext, $SFMLParser$BooleanNegationContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanNegationContext"
import {$SFMLParser$BooleanConjunctionContext, $SFMLParser$BooleanConjunctionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanConjunctionContext"
import {$SFMLParser$BooleanDisjunctionContext, $SFMLParser$BooleanDisjunctionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanDisjunctionContext"
import {$SFMLParser$ResourcecomparisonContext, $SFMLParser$ResourcecomparisonContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcecomparisonContext"
import {$SFMLParser$BooleanFalseContext, $SFMLParser$BooleanFalseContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanFalseContext"
import {$SFMLParser$OutputstatementContext, $SFMLParser$OutputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputstatementContext"
import {$SFMLParser$SecondsContext, $SFMLParser$SecondsContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SecondsContext"
import {$SFMLParser$TimerTriggerContext, $SFMLParser$TimerTriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TimerTriggerContext"
import {$SFMLParser$StringResourceContext, $SFMLParser$StringResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringResourceContext"
import {$SFMLParser$SlotqualifierContext, $SFMLParser$SlotqualifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SlotqualifierContext"
import {$SFMLParser$BooleanRedstoneContext, $SFMLParser$BooleanRedstoneContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanRedstoneContext"
import {$SFMLParser$ListedSidesContext, $SFMLParser$ListedSidesContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ListedSidesContext"
import {$SFMLVisitor, $SFMLVisitor$Type} from "packages/ca/teamdman/sfml/$SFMLVisitor"
import {$SFMLParser$InputstatementContext, $SFMLParser$InputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputstatementContext"
import {$SFMLParser$ComparisonOpContext, $SFMLParser$ComparisonOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext"
import {$SFMLParser$RangeContext, $SFMLParser$RangeContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangeContext"
import {$SFMLParser$BooleanHasContext, $SFMLParser$BooleanHasContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanHasContext"
import {$SFMLParser$OutputStatementStatementContext, $SFMLParser$OutputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputStatementStatementContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$SFMLParser$ProgramContext, $SFMLParser$ProgramContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ProgramContext"
import {$SFMLParser$BooleanTrueContext, $SFMLParser$BooleanTrueContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanTrueContext"
import {$AbstractParseTreeVisitor, $AbstractParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$AbstractParseTreeVisitor"
import {$SFMLParser$IfstatementContext, $SFMLParser$IfstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IfstatementContext"
import {$SFMLParser$LimitMovementContext, $SFMLParser$LimitMovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitMovementContext"
import {$SFMLParser$RangesetContext, $SFMLParser$RangesetContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangesetContext"

export class $SFMLBaseVisitor<T> extends $AbstractParseTreeVisitor<(T)> implements $SFMLVisitor<(T)> {

constructor()

public "visitString"(arg0: $SFMLParser$StringContext$Type): T
public "visitIfStatementStatement"(arg0: $SFMLParser$IfStatementStatementContext$Type): T
public "visitResourcelimit"(arg0: $SFMLParser$ResourcelimitContext$Type): T
public "visitForgetstatement"(arg0: $SFMLParser$ForgetstatementContext$Type): T
public "visitForgetStatementStatement"(arg0: $SFMLParser$ForgetStatementStatementContext$Type): T
public "visitIfstatement"(arg0: $SFMLParser$IfstatementContext$Type): T
public "visitInputstatement"(arg0: $SFMLParser$InputstatementContext$Type): T
public "visitBooleanConjunction"(arg0: $SFMLParser$BooleanConjunctionContext$Type): T
public "visitInputStatementStatement"(arg0: $SFMLParser$InputStatementStatementContext$Type): T
public "visitOutputStatementStatement"(arg0: $SFMLParser$OutputStatementStatementContext$Type): T
public "visitBooleanRedstone"(arg0: $SFMLParser$BooleanRedstoneContext$Type): T
public "visitBooleanNegation"(arg0: $SFMLParser$BooleanNegationContext$Type): T
public "visitResourcecomparison"(arg0: $SFMLParser$ResourcecomparisonContext$Type): T
public "visitQuantityRetentionLimit"(arg0: $SFMLParser$QuantityRetentionLimitContext$Type): T
public "visitRetentionLimit"(arg0: $SFMLParser$RetentionLimitContext$Type): T
public "visitBooleanDisjunction"(arg0: $SFMLParser$BooleanDisjunctionContext$Type): T
public "visitStringResource"(arg0: $SFMLParser$StringResourceContext$Type): T
public "visitQuantityLimit"(arg0: $SFMLParser$QuantityLimitContext$Type): T
public "visitQuantity"(arg0: $SFMLParser$QuantityContext$Type): T
public "visitBooleanTrue"(arg0: $SFMLParser$BooleanTrueContext$Type): T
public "visitNumber"(arg0: $SFMLParser$NumberContext$Type): T
public "visitRangeset"(arg0: $SFMLParser$RangesetContext$Type): T
public "visitRange"(arg0: $SFMLParser$RangeContext$Type): T
public "visitStringLabel"(arg0: $SFMLParser$StringLabelContext$Type): T
public "visitSlotqualifier"(arg0: $SFMLParser$SlotqualifierContext$Type): T
public "visitBlock"(arg0: $SFMLParser$BlockContext$Type): T
public "visitPulseTrigger"(arg0: $SFMLParser$PulseTriggerContext$Type): T
public "visitResourceLimitMovement"(arg0: $SFMLParser$ResourceLimitMovementContext$Type): T
public "visitOutputstatement"(arg0: $SFMLParser$OutputstatementContext$Type): T
public "visitResourceexclusion"(arg0: $SFMLParser$ResourceexclusionContext$Type): T
public "visitOutputmatchers"(arg0: $SFMLParser$OutputmatchersContext$Type): T
public "visitLabelaccess"(arg0: $SFMLParser$LabelaccessContext$Type): T
public "visitRetention"(arg0: $SFMLParser$RetentionContext$Type): T
public "visitProgram"(arg0: $SFMLParser$ProgramContext$Type): T
public "visitTimerTrigger"(arg0: $SFMLParser$TimerTriggerContext$Type): T
public "visitName"(arg0: $SFMLParser$NameContext$Type): T
public "visitTicks"(arg0: $SFMLParser$TicksContext$Type): T
public "visitTick"(arg0: $SFMLParser$TickContext$Type): T
public "visitSeconds"(arg0: $SFMLParser$SecondsContext$Type): T
public "visitLimitMovement"(arg0: $SFMLParser$LimitMovementContext$Type): T
public "visitInputmatchers"(arg0: $SFMLParser$InputmatchersContext$Type): T
public "visitEachSide"(arg0: $SFMLParser$EachSideContext$Type): T
public "visitSide"(arg0: $SFMLParser$SideContext$Type): T
public "visitBooleanHas"(arg0: $SFMLParser$BooleanHasContext$Type): T
public "visitListedSides"(arg0: $SFMLParser$ListedSidesContext$Type): T
public "visitRoundrobin"(arg0: $SFMLParser$RoundrobinContext$Type): T
public "visitBooleanFalse"(arg0: $SFMLParser$BooleanFalseContext$Type): T
public "visitBooleanParen"(arg0: $SFMLParser$BooleanParenContext$Type): T
public "visitResource"(arg0: $SFMLParser$ResourceContext$Type): T
public "visitComparisonOp"(arg0: $SFMLParser$ComparisonOpContext$Type): T
public "visitRawLabel"(arg0: $SFMLParser$RawLabelContext$Type): T
public "visitSetOp"(arg0: $SFMLParser$SetOpContext$Type): T
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLBaseVisitor$Type<T> = ($SFMLBaseVisitor<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLBaseVisitor_<T> = $SFMLBaseVisitor$Type<(T)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ForgetstatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$LabelContext, $SFMLParser$LabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ForgetstatementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "label"(arg0: integer): $SFMLParser$LabelContext
public "label"(): $List<($SFMLParser$LabelContext)>
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "COMMA"(arg0: integer): $TerminalNode
public "COMMA"(): $List<($TerminalNode)>
public "FORGET"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ForgetstatementContext$Type = ($SFMLParser$ForgetstatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ForgetstatementContext_ = $SFMLParser$ForgetstatementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceLimit" {
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ResourceIdSet, $ResourceIdSet$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdSet"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$InputResourceTracker, $InputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$InputResourceTracker"
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$OutputResourceTracker, $OutputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$OutputResourceTracker"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Limit, $Limit$Type} from "packages/ca/teamdman/sfml/ast/$Limit"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $ResourceLimit<STACK, ITEM, CAP> extends $Record implements $ASTNode, $Predicate<(any)> {
static readonly "TAKE_ALL_LEAVE_NONE": $ResourceLimit<(any), (any), (any)>
static readonly "ACCEPT_ALL_WITHOUT_RESTRAINT": $ResourceLimit<(any), (any), (any)>

constructor(resourceId: $ResourceIdentifier$Type<(STACK), (ITEM), (CAP)>, limit: $Limit$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: any): boolean
public "limit"(): $Limit
public "resourceId"(): $ResourceIdentifier<(STACK), (ITEM), (CAP)>
public "withLimit"(arg0: $Limit$Type): $ResourceLimit<(STACK), (ITEM), (CAP)>
public "toStringCondensed"(arg0: $Limit$Type): string
public "withDefaults"(arg0: $Limit$Type): $ResourceLimit<(STACK), (ITEM), (CAP)>
public "gatherInputTrackers"(arg0: $Consumer$Type<($InputResourceTracker$Type<(any), (any), (any)>)>, arg1: $ResourceIdSet$Type): void
public "gatherOutputTrackers"(arg0: $Consumer$Type<($OutputResourceTracker$Type<(any), (any), (any)>)>, arg1: $ResourceIdSet$Type): void
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
public "negate"(): $Predicate<(any)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public static "isEqual"<T>(arg0: any): $Predicate<(any)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceLimit$Type<STACK, ITEM, CAP> = ($ResourceLimit<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceLimit_<STACK, ITEM, CAP> = $ResourceLimit$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$StringContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$StringContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "STRING"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$StringContext$Type = ($SFMLParser$StringContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$StringContext_ = $SFMLParser$StringContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceComparer" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$SetOperator, $SetOperator$Type} from "packages/ca/teamdman/sfml/ast/$SetOperator"
import {$ComparisonOperator, $ComparisonOperator$Type} from "packages/ca/teamdman/sfml/ast/$ComparisonOperator"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$BoolExpr, $BoolExpr$Type} from "packages/ca/teamdman/sfml/ast/$BoolExpr"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"
import {$ResourceQuantity, $ResourceQuantity$Type} from "packages/ca/teamdman/sfml/ast/$ResourceQuantity"

export class $ResourceComparer<STACK, ITEM, CAP> extends $Record implements $ASTNode {

constructor(op: $ComparisonOperator$Type, quantity: $ResourceQuantity$Type, res: $ResourceIdentifier$Type<(STACK), (ITEM), (CAP)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "res"(): $ResourceIdentifier<(STACK), (ITEM), (CAP)>
public "op"(): $ComparisonOperator
public "quantity"(): $ResourceQuantity
public "toBooleanExpression"(arg0: $SetOperator$Type, arg1: $LabelAccess$Type, arg2: string): $BoolExpr
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceComparer$Type<STACK, ITEM, CAP> = ($ResourceComparer<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceComparer_<STACK, ITEM, CAP> = $ResourceComparer$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceIdentifier" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"

export class $ResourceIdentifier<STACK, ITEM, CAP> implements $ASTNode, $Predicate<(any)> {
static readonly "MATCH_ALL": $ResourceIdentifier<(any), (any), (any)>
readonly "resourceTypeNamespace": string
readonly "resourceTypeName": string
readonly "resourceNamespace": string
readonly "resourceName": string

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

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "test"(arg0: any): boolean
public "getLocation"(): $Optional<($ResourceLocation)>
public "expand"(): $List<($ResourceIdentifier<(STACK), (ITEM), (CAP)>)>
public static "fromString"<STACK, ITEM, CAP>(arg0: string): $ResourceIdentifier<(STACK), (ITEM), (CAP)>
public "matchesStack"(arg0: $ResourceLocation$Type): boolean
public "assertValid"(): void
public "getResourceType"(): $ResourceType<(STACK), (ITEM), (CAP)>
public "toStringCondensed"(): string
public "usesRegex"(): boolean
public "setResourceTypeCache"(arg0: $ResourceType$Type<(STACK), (ITEM), (CAP)>): void
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
public "negate"(): $Predicate<(any)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public static "isEqual"<T>(arg0: any): $Predicate<(any)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
get "location"(): $Optional<($ResourceLocation)>
get "resourceType"(): $ResourceType<(STACK), (ITEM), (CAP)>
set "resourceTypeCache"(value: $ResourceType$Type<(STACK), (ITEM), (CAP)>)
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceIdentifier$Type<STACK, ITEM, CAP> = ($ResourceIdentifier<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceIdentifier_<STACK, ITEM, CAP> = $ResourceIdentifier$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$OutputmatchersContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$MovementContext, $SFMLParser$MovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$MovementContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$OutputmatchersContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "movement"(): $SFMLParser$MovementContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$OutputmatchersContext$Type = ($SFMLParser$OutputmatchersContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$OutputmatchersContext_ = $SFMLParser$OutputmatchersContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ComparisonOpContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "EQ"(): $TerminalNode
public "LT"(): $TerminalNode
public "LE"(): $TerminalNode
public "GT"(): $TerminalNode
public "GE"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "GT_SYMBOL"(): $TerminalNode
public "LE_SYMBOL"(): $TerminalNode
public "EQ_SYMBOL"(): $TerminalNode
public "GE_SYMBOL"(): $TerminalNode
public "LT_SYMBOL"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ComparisonOpContext$Type = ($SFMLParser$ComparisonOpContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ComparisonOpContext_ = $SFMLParser$ComparisonOpContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$InputResourceTracker" {
import {$ResourceIdSet, $ResourceIdSet$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdSet"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$AtomicLong, $AtomicLong$Type} from "packages/java/util/concurrent/atomic/$AtomicLong"
import {$ResourceLimit, $ResourceLimit$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimit"

export class $InputResourceTracker<STACK, ITEM, CAP> implements $Predicate<(any)> {

constructor(arg0: $ResourceLimit$Type<(STACK), (ITEM), (CAP)>, arg1: $ResourceIdSet$Type, arg2: $AtomicLong$Type, arg3: $AtomicLong$Type)

public "toString"(): string
public "test"(arg0: any): boolean
public "isDone"(): boolean
public "matchesCapabilityType"(arg0: any): boolean
public "getExistingRetentionObligation"(arg0: integer): long
public "trackRetentionObligation"(arg0: integer, arg1: long): void
public "getRemainingRetentionObligation"(): long
public "getResourceLimit"(): $ResourceLimit<(STACK), (ITEM), (CAP)>
public "trackTransfer"(arg0: long): void
public "getMaxTransferable"(): long
public "negate"(): $Predicate<(any)>
public "and"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public static "isEqual"<T>(arg0: any): $Predicate<(any)>
public static "not"<T>(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
public "or"(arg0: $Predicate$Type<(any)>): $Predicate<(any)>
get "done"(): boolean
get "remainingRetentionObligation"(): long
get "resourceLimit"(): $ResourceLimit<(STACK), (ITEM), (CAP)>
get "maxTransferable"(): long
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $InputResourceTracker$Type<STACK, ITEM, CAP> = ($InputResourceTracker<(STACK), (ITEM), (CAP)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $InputResourceTracker_<STACK, ITEM, CAP> = $InputResourceTracker$Type<(STACK), (ITEM), (CAP)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BoolexprContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$BoolexprContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BoolexprContext$Type = ($SFMLParser$BoolexprContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BoolexprContext_ = $SFMLParser$BoolexprContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$IfStatement" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$ShortStatement, $ShortStatement$Type} from "packages/ca/teamdman/sfml/ast/$ShortStatement"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Block, $Block$Type} from "packages/ca/teamdman/sfml/ast/$Block"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$BoolExpr, $BoolExpr$Type} from "packages/ca/teamdman/sfml/ast/$BoolExpr"

export class $IfStatement extends $Record implements $ASTNode, $Statement, $ShortStatement {

constructor(condition: $BoolExpr$Type, trueBlock: $Block$Type, falseBlock: $Block$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "tick"(arg0: $ProgramContext$Type): void
public "getStatements"(): $List<($Statement)>
public "toStringShort"(): string
public "condition"(): $BoolExpr
public "falseBlock"(): $Block
public "trueBlock"(): $Block
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $IfStatement$Type = ($IfStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $IfStatement_ = $IfStatement$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ResourceLimits" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ResourceIdSet, $ResourceIdSet$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdSet"
import {$OutputResourceTracker, $OutputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$OutputResourceTracker"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Limit, $Limit$Type} from "packages/ca/teamdman/sfml/ast/$Limit"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ResourceType, $ResourceType$Type} from "packages/ca/teamdman/sfm/common/resourcetype/$ResourceType"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$InputResourceTracker, $InputResourceTracker$Type} from "packages/ca/teamdman/sfm/common/program/$InputResourceTracker"

export class $ResourceLimits extends $Record implements $ASTNode {

constructor(resourceLimits: $List$Type<(any)>, exclusions: $ResourceIdSet$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "createInputTrackers"(): $List<($InputResourceTracker<(any), (any), (any)>)>
public "exclusions"(): $ResourceIdSet
public "createOutputTrackers"(): $List<($OutputResourceTracker<(any), (any), (any)>)>
public "getReferencedResourceTypes"(): $Stream<($ResourceType)>
public "toStringPretty"(arg0: $Limit$Type): string
public "resourceLimits"(): $List<(any)>
public "withExclusions"(arg0: $ResourceIdSet$Type): $ResourceLimits
public "withDefaults"(arg0: $Limit$Type): $ResourceLimits
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "referencedResourceTypes"(): $Stream<($ResourceType)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ResourceLimits$Type = ($ResourceLimits);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ResourceLimits_ = $ResourceLimits$Type;
}}
declare module "packages/ca/teamdman/sfm/common/cablenetwork/$ICableBlock" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ICableBlock {

}

export namespace $ICableBlock {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ICableBlock$Type = ($ICableBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ICableBlock_ = $ICableBlock$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Block" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $Block extends $Record implements $Statement {

constructor(statements: $List$Type<($Statement$Type)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "tick"(arg0: $ProgramContext$Type): void
public "statements"(): $List<($Statement)>
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Block$Type = ($Block);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Block_ = $Block$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourceexclusionContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$ResourceidContext, $SFMLParser$ResourceidContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ResourceexclusionContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "COMMA"(): $List<($TerminalNode)>
public "COMMA"(arg0: integer): $TerminalNode
public "resourceid"(arg0: integer): $SFMLParser$ResourceidContext
public "resourceid"(): $List<($SFMLParser$ResourceidContext)>
public "EXCEPT"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourceexclusionContext$Type = ($SFMLParser$ResourceexclusionContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourceexclusionContext_ = $SFMLParser$ResourceexclusionContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$StringHolder" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $StringHolder extends $Record implements $ASTNode {

constructor(value: string)

public "value"(): string
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $StringHolder$Type = ($StringHolder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $StringHolder_ = $StringHolder$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ASTBuilder" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$StringHolder, $StringHolder$Type} from "packages/ca/teamdman/sfml/ast/$StringHolder"
import {$SFMLParser$SideContext, $SFMLParser$SideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SideContext"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$SFMLParser$InputStatementStatementContext, $SFMLParser$InputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputStatementStatementContext"
import {$SFMLParser$ResourceContext, $SFMLParser$ResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceContext"
import {$SFMLParser$ResourcelimitContext, $SFMLParser$ResourcelimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcelimitContext"
import {$SFMLParser$RoundrobinContext, $SFMLParser$RoundrobinContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RoundrobinContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$RawLabelContext, $SFMLParser$RawLabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RawLabelContext"
import {$RoundRobin, $RoundRobin$Type} from "packages/ca/teamdman/sfml/ast/$RoundRobin"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"
import {$SFMLParser$TicksContext, $SFMLParser$TicksContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TicksContext"
import {$SFMLParser$QuantityLimitContext, $SFMLParser$QuantityLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityLimitContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$DirectionQualifier, $DirectionQualifier$Type} from "packages/ca/teamdman/sfml/ast/$DirectionQualifier"
import {$SFMLParser$QuantityRetentionLimitContext, $SFMLParser$QuantityRetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityRetentionLimitContext"
import {$SFMLParser$QuantityContext, $SFMLParser$QuantityContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext"
import {$SetOperator, $SetOperator$Type} from "packages/ca/teamdman/sfml/ast/$SetOperator"
import {$SFMLParser$TickContext, $SFMLParser$TickContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TickContext"
import {$SFMLParser$BooleanParenContext, $SFMLParser$BooleanParenContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanParenContext"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$SFMLParser$EachSideContext, $SFMLParser$EachSideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$EachSideContext"
import {$SFMLParser$NameContext, $SFMLParser$NameContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NameContext"
import {$SFMLParser$SetOpContext, $SFMLParser$SetOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SetOpContext"
import {$NumberRangeSet, $NumberRangeSet$Type} from "packages/ca/teamdman/sfml/ast/$NumberRangeSet"
import {$SFMLParser$RetentionLimitContext, $SFMLParser$RetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionLimitContext"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$Pair, $Pair$Type} from "packages/com/mojang/datafixers/util/$Pair"
import {$SFMLParser$PulseTriggerContext, $SFMLParser$PulseTriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$PulseTriggerContext"
import {$SFMLParser$BooleanNegationContext, $SFMLParser$BooleanNegationContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanNegationContext"
import {$SFMLParser$BooleanDisjunctionContext, $SFMLParser$BooleanDisjunctionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanDisjunctionContext"
import {$Interval, $Interval$Type} from "packages/ca/teamdman/sfml/ast/$Interval"
import {$SFMLBaseVisitor, $SFMLBaseVisitor$Type} from "packages/ca/teamdman/sfml/$SFMLBaseVisitor"
import {$Limit, $Limit$Type} from "packages/ca/teamdman/sfml/ast/$Limit"
import {$SFMLParser$SecondsContext, $SFMLParser$SecondsContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SecondsContext"
import {$OutputStatement, $OutputStatement$Type} from "packages/ca/teamdman/sfml/ast/$OutputStatement"
import {$ResourceQuantity, $ResourceQuantity$Type} from "packages/ca/teamdman/sfml/ast/$ResourceQuantity"
import {$SFMLParser$StringResourceContext, $SFMLParser$StringResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringResourceContext"
import {$SFMLParser$SlotqualifierContext, $SFMLParser$SlotqualifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SlotqualifierContext"
import {$SFMLParser$ListedSidesContext, $SFMLParser$ListedSidesContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ListedSidesContext"
import {$SFMLParser$ComparisonOpContext, $SFMLParser$ComparisonOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext"
import {$BoolExpr, $BoolExpr$Type} from "packages/ca/teamdman/sfml/ast/$BoolExpr"
import {$SFMLParser$OutputStatementStatementContext, $SFMLParser$OutputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputStatementStatementContext"
import {$LabelAccess, $LabelAccess$Type} from "packages/ca/teamdman/sfml/ast/$LabelAccess"
import {$InputStatement, $InputStatement$Type} from "packages/ca/teamdman/sfml/ast/$InputStatement"
import {$Side, $Side$Type} from "packages/ca/teamdman/sfml/ast/$Side"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$Number, $Number$Type} from "packages/ca/teamdman/sfml/ast/$Number"
import {$ComparisonOperator, $ComparisonOperator$Type} from "packages/ca/teamdman/sfml/ast/$ComparisonOperator"
import {$ResourceLimit, $ResourceLimit$Type} from "packages/ca/teamdman/sfml/ast/$ResourceLimit"
import {$SFMLParser$BooleanTrueContext, $SFMLParser$BooleanTrueContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanTrueContext"

export class $ASTBuilder extends $SFMLBaseVisitor<($ASTNode)> {

constructor()

public "visitString"(arg0: $SFMLParser$StringContext$Type): $StringHolder
public "getNodeAtIndex"(arg0: integer): $Optional<($ASTNode)>
public "visitResourcelimit"(arg0: $SFMLParser$ResourcelimitContext$Type): $ResourceLimit<(any), (any), (any)>
public "visitInputStatementStatement"(arg0: $SFMLParser$InputStatementStatementContext$Type): $InputStatement
public "visitOutputStatementStatement"(arg0: $SFMLParser$OutputStatementStatementContext$Type): $OutputStatement
public "visitBooleanNegation"(arg0: $SFMLParser$BooleanNegationContext$Type): $BoolExpr
public "visitQuantityRetentionLimit"(arg0: $SFMLParser$QuantityRetentionLimitContext$Type): $Limit
public "visitRetentionLimit"(arg0: $SFMLParser$RetentionLimitContext$Type): $Limit
public "visitBooleanDisjunction"(arg0: $SFMLParser$BooleanDisjunctionContext$Type): $BoolExpr
public "visitStringResource"(arg0: $SFMLParser$StringResourceContext$Type): $ResourceIdentifier<(any), (any), (any)>
public "getNodesUnderCursor"(arg0: integer): $List<($Pair<($ASTNode), ($ParserRuleContext)>)>
public "getLineColumnForNode"(arg0: $ASTNode$Type): string
public "setLocationFromOtherNode"(arg0: $ASTNode$Type, arg1: $ASTNode$Type): void
public "visitQuantityLimit"(arg0: $SFMLParser$QuantityLimitContext$Type): $Limit
public "visitQuantity"(arg0: $SFMLParser$QuantityContext$Type): $ResourceQuantity
public "visitBooleanTrue"(arg0: $SFMLParser$BooleanTrueContext$Type): $BoolExpr
public "visitNumber"(arg0: $SFMLParser$NumberContext$Type): $Number
public "visitSlotqualifier"(arg0: $SFMLParser$SlotqualifierContext$Type): $NumberRangeSet
public "visitPulseTrigger"(arg0: $SFMLParser$PulseTriggerContext$Type): $ASTNode
public "visitLabelaccess"(arg0: $SFMLParser$LabelaccessContext$Type): $LabelAccess
public "visitName"(arg0: $SFMLParser$NameContext$Type): $StringHolder
public "visitTicks"(arg0: $SFMLParser$TicksContext$Type): $Interval
public "visitTick"(arg0: $SFMLParser$TickContext$Type): $Interval
public "visitSeconds"(arg0: $SFMLParser$SecondsContext$Type): $Interval
public "visitEachSide"(arg0: $SFMLParser$EachSideContext$Type): $DirectionQualifier
public "visitSide"(arg0: $SFMLParser$SideContext$Type): $Side
public "visitListedSides"(arg0: $SFMLParser$ListedSidesContext$Type): $DirectionQualifier
public "visitRoundrobin"(arg0: $SFMLParser$RoundrobinContext$Type): $RoundRobin
public "visitBooleanParen"(arg0: $SFMLParser$BooleanParenContext$Type): $BoolExpr
public "visitResource"(arg0: $SFMLParser$ResourceContext$Type): $ASTNode
public "visitComparisonOp"(arg0: $SFMLParser$ComparisonOpContext$Type): $ComparisonOperator
public "visitRawLabel"(arg0: $SFMLParser$RawLabelContext$Type): $Label
public "getIndexForNode"(arg0: $ASTNode$Type): integer
public "getContextForNode"(arg0: $ASTNode$Type): $Optional<($ParserRuleContext)>
public "visitSetOp"(arg0: $SFMLParser$SetOpContext$Type): $SetOperator
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ASTBuilder$Type = ($ASTBuilder);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ASTBuilder_ = $ASTBuilder$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$CapabilityConsumer" {
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"

export interface $CapabilityConsumer<T> {

 "accept"(arg0: $Label$Type, arg1: $BlockPos$Type, arg2: $Direction$Type, arg3: T): void

(arg0: $Label$Type, arg1: $BlockPos$Type, arg2: $Direction$Type, arg3: T): void
}

export namespace $CapabilityConsumer {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $CapabilityConsumer$Type<T> = ($CapabilityConsumer<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $CapabilityConsumer_<T> = $CapabilityConsumer$Type<(T)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$MovementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$MovementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$MovementContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$MovementContext$Type = ($SFMLParser$MovementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$MovementContext_ = $SFMLParser$MovementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ComparisonOperator" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$BiPredicate, $BiPredicate$Type} from "packages/java/util/function/$BiPredicate"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $ComparisonOperator extends $Enum<($ComparisonOperator)> implements $ASTNode, $BiPredicate<(long), (long)> {
static readonly "GREATER": $ComparisonOperator
static readonly "LESSER": $ComparisonOperator
static readonly "EQUALS": $ComparisonOperator
static readonly "LESSER_OR_EQUAL": $ComparisonOperator
static readonly "GREATER_OR_EQUAL": $ComparisonOperator


public static "values"(): ($ComparisonOperator)[]
public "test"(arg0: long, arg1: long): boolean
public static "valueOf"(arg0: string): $ComparisonOperator
public static "from"(arg0: string): $ComparisonOperator
public "getSourceCode"(): string
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
public "negate"(): $BiPredicate<(long), (long)>
public "and"(arg0: $BiPredicate$Type<(any), (any)>): $BiPredicate<(long), (long)>
public "or"(arg0: $BiPredicate$Type<(any), (any)>): $BiPredicate<(long), (long)>
get "sourceCode"(): string
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ComparisonOperator$Type = (("greater_or_equal") | ("lesser") | ("equals") | ("lesser_or_equal") | ("greater")) | ($ComparisonOperator);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ComparisonOperator_ = $ComparisonOperator$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ASTNode" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export interface $ASTNode {

 "getStatements"(): $List<($Statement)>
 "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
 "getDescendantStatements"(): $Stream<($Statement)>
}

export namespace $ASTNode {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ASTNode$Type = ($ASTNode);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ASTNode_ = $ASTNode$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$TimerTriggerContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$IntervalContext, $SFMLParser$IntervalContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IntervalContext"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$SFMLParser$TriggerContext, $SFMLParser$TriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TriggerContext"
import {$SFMLParser$BlockContext, $SFMLParser$BlockContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BlockContext"
import {$List, $List$Type} from "packages/java/util/$List"

export class $SFMLParser$TimerTriggerContext extends $SFMLParser$TriggerContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$TriggerContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "block"(): $SFMLParser$BlockContext
public "interval"(): $SFMLParser$IntervalContext
public "END"(): $TerminalNode
public "DO"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "EVERY"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$TimerTriggerContext$Type = ($SFMLParser$TimerTriggerContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$TimerTriggerContext_ = $SFMLParser$TimerTriggerContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/logging/$TranslatableLogger" {
import {$ArrayDeque, $ArrayDeque$Type} from "packages/java/util/$ArrayDeque"
import {$TranslatableContents, $TranslatableContents$Type} from "packages/net/minecraft/network/chat/contents/$TranslatableContents"
import {$Consumer, $Consumer$Type} from "packages/java/util/function/$Consumer"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Instant, $Instant$Type} from "packages/org/apache/logging/log4j/core/time/$Instant"
import {$Collection, $Collection$Type} from "packages/java/util/$Collection"
import {$Level, $Level$Type} from "packages/org/apache/logging/log4j/$Level"
import {$TranslatableLogEvent, $TranslatableLogEvent$Type} from "packages/ca/teamdman/sfm/common/logging/$TranslatableLogEvent"

export class $TranslatableLogger {

constructor(arg0: string)

public "clear"(): void
public static "decode"(arg0: $FriendlyByteBuf$Type): $ArrayDeque<($TranslatableLogEvent)>
public "info"(arg0: $TranslatableContents$Type): void
public "info"(arg0: $Consumer$Type<($Consumer$Type<($TranslatableContents$Type)>)>): void
public "trace"(arg0: $TranslatableContents$Type): void
public "trace"(arg0: $Consumer$Type<($Consumer$Type<($TranslatableContents$Type)>)>): void
public "debug"(arg0: $TranslatableContents$Type): void
public "debug"(arg0: $Consumer$Type<($Consumer$Type<($TranslatableContents$Type)>)>): void
public "error"(arg0: $Consumer$Type<($Consumer$Type<($TranslatableContents$Type)>)>): void
public "error"(arg0: $TranslatableContents$Type): void
public "warn"(arg0: $TranslatableContents$Type): void
public "warn"(arg0: $Consumer$Type<($Consumer$Type<($TranslatableContents$Type)>)>): void
public "getLogLevel"(): $Level
public "setLogLevel"(arg0: $Level$Type): void
public "pruneSoWeDontEatAllTheRam"(): void
public "getLogsAfter"(arg0: $Instant$Type): $ArrayDeque<($TranslatableLogEvent)>
public static "encodeAndDrain"(arg0: $Collection$Type<($TranslatableLogEvent$Type)>, arg1: $FriendlyByteBuf$Type): void
public static "comesAfter"(arg0: $Instant$Type, arg1: $Instant$Type): boolean
get "logLevel"(): $Level
set "logLevel"(value: $Level$Type)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TranslatableLogger$Type = ($TranslatableLogger);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TranslatableLogger_ = $TranslatableLogger$Type;
}}
declare module "packages/ca/teamdman/sfm/common/program/$ProgramContext" {
import {$Program, $Program$Type} from "packages/ca/teamdman/sfml/ast/$Program"
import {$ProgramBehaviour, $ProgramBehaviour$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramBehaviour"
import {$List, $List$Type} from "packages/java/util/$List"
import {$CableNetwork, $CableNetwork$Type} from "packages/ca/teamdman/sfm/common/cablenetwork/$CableNetwork"
import {$TranslatableLogger, $TranslatableLogger$Type} from "packages/ca/teamdman/sfm/common/logging/$TranslatableLogger"
import {$ManagerBlockEntity, $ManagerBlockEntity$Type} from "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity"
import {$LabelPositionHolder, $LabelPositionHolder$Type} from "packages/ca/teamdman/sfm/common/program/$LabelPositionHolder"
import {$SimulateExploreAllPathsProgramBehaviour, $SimulateExploreAllPathsProgramBehaviour$Type} from "packages/ca/teamdman/sfm/common/program/$SimulateExploreAllPathsProgramBehaviour"
import {$InputStatement, $InputStatement$Type} from "packages/ca/teamdman/sfml/ast/$InputStatement"

export class $ProgramContext {

constructor(arg0: $Program$Type, arg1: $ManagerBlockEntity$Type, arg2: $ProgramBehaviour$Type)

public "toString"(): string
public "getLogger"(): $TranslatableLogger
public static "createSimulationContext"(arg0: $Program$Type, arg1: $LabelPositionHolder$Type, arg2: integer, arg3: $SimulateExploreAllPathsProgramBehaviour$Type): $ProgramContext
public "free"(): void
public "fork"(): $ProgramContext
public "getInputs"(): $List<($InputStatement)>
public "getProgram"(): $Program
public "getManager"(): $ManagerBlockEntity
public "didSomething"(): boolean
public "getNetwork"(): $CableNetwork
public "getLabelPositionHolder"(): $LabelPositionHolder
public "getBehaviour"(): $ProgramBehaviour
public "getRedstonePulses"(): integer
public "setDidSomething"(arg0: boolean): void
public "addInput"(arg0: $InputStatement$Type): void
get "logger"(): $TranslatableLogger
get "inputs"(): $List<($InputStatement)>
get "program"(): $Program
get "manager"(): $ManagerBlockEntity
get "network"(): $CableNetwork
get "labelPositionHolder"(): $LabelPositionHolder
get "behaviour"(): $ProgramBehaviour
get "redstonePulses"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ProgramContext$Type = ($ProgramContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ProgramContext_ = $ProgramContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$InputstatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$SFMLParser$InputmatchersContext, $SFMLParser$InputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputmatchersContext"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"
import {$SFMLParser$ResourceexclusionContext, $SFMLParser$ResourceexclusionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceexclusionContext"

export class $SFMLParser$InputstatementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "INPUT"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "FROM"(): $TerminalNode
public "labelaccess"(): $SFMLParser$LabelaccessContext
public "inputmatchers"(): $SFMLParser$InputmatchersContext
public "resourceexclusion"(): $SFMLParser$ResourceexclusionContext
public "EACH"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$InputstatementContext$Type = ($SFMLParser$InputstatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$InputstatementContext_ = $SFMLParser$InputstatementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$NumberRange" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $NumberRange extends $Record implements $ASTNode {
static readonly "MAX_RANGE": $NumberRange

constructor(start: long, end: long)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "start"(): long
public "end"(): long
public "contains"(arg0: integer): boolean
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $NumberRange$Type = ($NumberRange);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $NumberRange_ = $NumberRange$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RetentionLimitContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LimitContext, $SFMLParser$LimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitContext"
import {$SFMLParser$RetentionContext, $SFMLParser$RetentionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RetentionLimitContext extends $SFMLParser$LimitContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$LimitContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "retention"(): $SFMLParser$RetentionContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RetentionLimitContext$Type = ($SFMLParser$RetentionLimitContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RetentionLimitContext_ = $SFMLParser$RetentionLimitContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanFalseContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanFalseContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "FALSE"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanFalseContext$Type = ($SFMLParser$BooleanFalseContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanFalseContext_ = $SFMLParser$BooleanFalseContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ForgetStatement" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ProgramContext, $ProgramContext$Type} from "packages/ca/teamdman/sfm/common/program/$ProgramContext"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$Label, $Label$Type} from "packages/ca/teamdman/sfml/ast/$Label"

export class $ForgetStatement extends $Record implements $Statement {

constructor(labelToForget: $Set$Type<($Label$Type)>)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "tick"(arg0: $ProgramContext$Type): void
public "labelToForget"(): $Set<($Label)>
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ForgetStatement$Type = ($ForgetStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ForgetStatement_ = $ForgetStatement$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$ShortStatement" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $ShortStatement {

 "toStringShort"(): string

(): string
}

export namespace $ShortStatement {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ShortStatement$Type = ($ShortStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ShortStatement_ = $ShortStatement$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$PrettyStatement" {
export {} // Mark the file as a module, do not remove unless there are other import/exports!
export interface $PrettyStatement {

 "toStringPretty"(): string

(): string
}

export namespace $PrettyStatement {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PrettyStatement$Type = ($PrettyStatement);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrettyStatement_ = $PrettyStatement$Type;
}}
declare module "packages/ca/teamdman/sfm/common/block/$WaterTankBlock" {
import {$LevelAccessor, $LevelAccessor$Type} from "packages/net/minecraft/world/level/$LevelAccessor"
import {$SoundEvent, $SoundEvent$Type} from "packages/net/minecraft/sounds/$SoundEvent"
import {$BooleanProperty, $BooleanProperty$Type} from "packages/net/minecraft/world/level/block/state/properties/$BooleanProperty"
import {$Fluid, $Fluid$Type} from "packages/net/minecraft/world/level/material/$Fluid"
import {$EntityBlock, $EntityBlock$Type} from "packages/net/minecraft/world/level/block/$EntityBlock"
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 {$LiquidBlockContainer, $LiquidBlockContainer$Type} from "packages/net/minecraft/world/level/block/$LiquidBlockContainer"
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 {$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 {$BucketPickup, $BucketPickup$Type} from "packages/net/minecraft/world/level/block/$BucketPickup"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$List, $List$Type} from "packages/java/util/$List"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$BlockPlaceContext, $BlockPlaceContext$Type} from "packages/net/minecraft/world/item/context/$BlockPlaceContext"
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 {$StateDefinition, $StateDefinition$Type} from "packages/net/minecraft/world/level/block/state/$StateDefinition"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$BaseEntityBlock, $BaseEntityBlock$Type} from "packages/net/minecraft/world/level/block/$BaseEntityBlock"
import {$RenderShape, $RenderShape$Type} from "packages/net/minecraft/world/level/block/$RenderShape"

export class $WaterTankBlock extends $BaseEntityBlock implements $EntityBlock, $BucketPickup, $LiquidBlockContainer {
static readonly "IN_WATER": $BooleanProperty
/**
 * 
 * @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()

public "isActive"(arg0: $LevelAccessor$Type, arg1: $BlockPos$Type): boolean
public "onPlace"(arg0: $BlockState$Type, arg1: $Level$Type, arg2: $BlockPos$Type, arg3: $BlockState$Type, arg4: boolean): void
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 "getRenderShape"(arg0: $BlockState$Type): $RenderShape
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $BlockGetter$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public "pickupBlock"(arg0: $LevelAccessor$Type, arg1: $BlockPos$Type, arg2: $BlockState$Type): $ItemStack
public "canPlaceLiquid"(arg0: $BlockGetter$Type, arg1: $BlockPos$Type, arg2: $BlockState$Type, arg3: $Fluid$Type): boolean
public "placeLiquid"(arg0: $LevelAccessor$Type, arg1: $BlockPos$Type, arg2: $BlockState$Type, arg3: $FluidState$Type): boolean
public "getPickupSound"(): $Optional<($SoundEvent)>
public "getStateForPlacement"(arg0: $BlockPlaceContext$Type): $BlockState
public "recount"(arg0: $Level$Type, arg1: $BlockPos$Type): void
public "newBlockEntity"(arg0: $BlockPos$Type, arg1: $BlockState$Type): $BlockEntity
public "getPickupSound"(arg0: $BlockState$Type): $Optional<($SoundEvent)>
get "pickupSound"(): $Optional<($SoundEvent)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $WaterTankBlock$Type = ($WaterTankBlock);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $WaterTankBlock_ = $WaterTankBlock$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$RoundRobin$Behaviour" {
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"

export class $RoundRobin$Behaviour extends $Enum<($RoundRobin$Behaviour)> {
static readonly "UNMODIFIED": $RoundRobin$Behaviour
static readonly "BY_BLOCK": $RoundRobin$Behaviour
static readonly "BY_LABEL": $RoundRobin$Behaviour


public static "values"(): ($RoundRobin$Behaviour)[]
public static "valueOf"(arg0: string): $RoundRobin$Behaviour
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $RoundRobin$Behaviour$Type = (("unmodified") | ("by_block") | ("by_label")) | ($RoundRobin$Behaviour);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $RoundRobin$Behaviour_ = $RoundRobin$Behaviour$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$InputmatchersContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$MovementContext, $SFMLParser$MovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$MovementContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$InputmatchersContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "movement"(): $SFMLParser$MovementContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$InputmatchersContext$Type = ($SFMLParser$InputmatchersContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$InputmatchersContext_ = $SFMLParser$InputmatchersContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Limit" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"
import {$ResourceQuantity, $ResourceQuantity$Type} from "packages/ca/teamdman/sfml/ast/$ResourceQuantity"

export class $Limit extends $Record implements $ASTNode {
static readonly "MAX_QUANTITY_NO_RETENTION": $Limit
static readonly "MAX_QUANTITY_MAX_RETENTION": $Limit
static readonly "UNSET": $Limit

constructor(quantity: $ResourceQuantity$Type, retention: $ResourceQuantity$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "retention"(): $ResourceQuantity
public "quantity"(): $ResourceQuantity
public "toStringCondensed"(arg0: $Limit$Type): string
public "withDefaults"(arg0: $Limit$Type): $Limit
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Limit$Type = ($Limit);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Limit_ = $Limit$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RawLabelContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$LabelContext, $SFMLParser$LabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RawLabelContext extends $SFMLParser$LabelContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$LabelContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "REDSTONE"(): $TerminalNode
public "IDENTIFIER"(): $TerminalNode
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RawLabelContext$Type = ($SFMLParser$RawLabelContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RawLabelContext_ = $SFMLParser$RawLabelContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLVisitor" {
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$SideContext, $SFMLParser$SideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SideContext"
import {$SFMLParser$InputStatementStatementContext, $SFMLParser$InputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputStatementStatementContext"
import {$SFMLParser$ResourceContext, $SFMLParser$ResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceContext"
import {$SFMLParser$ResourcelimitContext, $SFMLParser$ResourcelimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcelimitContext"
import {$SFMLParser$BlockContext, $SFMLParser$BlockContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BlockContext"
import {$SFMLParser$RoundrobinContext, $SFMLParser$RoundrobinContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RoundrobinContext"
import {$ErrorNode, $ErrorNode$Type} from "packages/org/antlr/v4/runtime/tree/$ErrorNode"
import {$SFMLParser$StringLabelContext, $SFMLParser$StringLabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringLabelContext"
import {$SFMLParser$ForgetstatementContext, $SFMLParser$ForgetstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ForgetstatementContext"
import {$SFMLParser$RawLabelContext, $SFMLParser$RawLabelContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RawLabelContext"
import {$SFMLParser$ResourceexclusionContext, $SFMLParser$ResourceexclusionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceexclusionContext"
import {$SFMLParser$LabelaccessContext, $SFMLParser$LabelaccessContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LabelaccessContext"
import {$SFMLParser$TicksContext, $SFMLParser$TicksContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TicksContext"
import {$SFMLParser$QuantityLimitContext, $SFMLParser$QuantityLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityLimitContext"
import {$SFMLParser$QuantityRetentionLimitContext, $SFMLParser$QuantityRetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityRetentionLimitContext"
import {$SFMLParser$QuantityContext, $SFMLParser$QuantityContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$QuantityContext"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$TickContext, $SFMLParser$TickContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TickContext"
import {$SFMLParser$InputmatchersContext, $SFMLParser$InputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputmatchersContext"
import {$SFMLParser$BooleanParenContext, $SFMLParser$BooleanParenContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanParenContext"
import {$SFMLParser$IfStatementStatementContext, $SFMLParser$IfStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IfStatementStatementContext"
import {$SFMLParser$StringContext, $SFMLParser$StringContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringContext"
import {$SFMLParser$EachSideContext, $SFMLParser$EachSideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$EachSideContext"
import {$SFMLParser$NameContext, $SFMLParser$NameContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NameContext"
import {$SFMLParser$SetOpContext, $SFMLParser$SetOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SetOpContext"
import {$SFMLParser$RetentionLimitContext, $SFMLParser$RetentionLimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionLimitContext"
import {$SFMLParser$OutputmatchersContext, $SFMLParser$OutputmatchersContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputmatchersContext"
import {$SFMLParser$RetentionContext, $SFMLParser$RetentionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RetentionContext"
import {$SFMLParser$ForgetStatementStatementContext, $SFMLParser$ForgetStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ForgetStatementStatementContext"
import {$SFMLParser$PulseTriggerContext, $SFMLParser$PulseTriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$PulseTriggerContext"
import {$SFMLParser$ResourceLimitMovementContext, $SFMLParser$ResourceLimitMovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceLimitMovementContext"
import {$SFMLParser$BooleanNegationContext, $SFMLParser$BooleanNegationContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanNegationContext"
import {$SFMLParser$BooleanConjunctionContext, $SFMLParser$BooleanConjunctionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanConjunctionContext"
import {$SFMLParser$BooleanDisjunctionContext, $SFMLParser$BooleanDisjunctionContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanDisjunctionContext"
import {$SFMLParser$ResourcecomparisonContext, $SFMLParser$ResourcecomparisonContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourcecomparisonContext"
import {$SFMLParser$BooleanFalseContext, $SFMLParser$BooleanFalseContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanFalseContext"
import {$SFMLParser$OutputstatementContext, $SFMLParser$OutputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputstatementContext"
import {$SFMLParser$SecondsContext, $SFMLParser$SecondsContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SecondsContext"
import {$SFMLParser$TimerTriggerContext, $SFMLParser$TimerTriggerContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$TimerTriggerContext"
import {$SFMLParser$StringResourceContext, $SFMLParser$StringResourceContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StringResourceContext"
import {$SFMLParser$SlotqualifierContext, $SFMLParser$SlotqualifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SlotqualifierContext"
import {$RuleNode, $RuleNode$Type} from "packages/org/antlr/v4/runtime/tree/$RuleNode"
import {$SFMLParser$BooleanRedstoneContext, $SFMLParser$BooleanRedstoneContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanRedstoneContext"
import {$SFMLParser$ListedSidesContext, $SFMLParser$ListedSidesContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ListedSidesContext"
import {$SFMLParser$InputstatementContext, $SFMLParser$InputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputstatementContext"
import {$SFMLParser$ComparisonOpContext, $SFMLParser$ComparisonOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext"
import {$SFMLParser$RangeContext, $SFMLParser$RangeContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangeContext"
import {$SFMLParser$BooleanHasContext, $SFMLParser$BooleanHasContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanHasContext"
import {$SFMLParser$OutputStatementStatementContext, $SFMLParser$OutputStatementStatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputStatementStatementContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$SFMLParser$ProgramContext, $SFMLParser$ProgramContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ProgramContext"
import {$SFMLParser$BooleanTrueContext, $SFMLParser$BooleanTrueContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BooleanTrueContext"
import {$SFMLParser$IfstatementContext, $SFMLParser$IfstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IfstatementContext"
import {$SFMLParser$LimitMovementContext, $SFMLParser$LimitMovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitMovementContext"
import {$SFMLParser$RangesetContext, $SFMLParser$RangesetContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$RangesetContext"

export interface $SFMLVisitor<T> extends $ParseTreeVisitor<(T)> {

 "visitString"(arg0: $SFMLParser$StringContext$Type): T
 "visitIfStatementStatement"(arg0: $SFMLParser$IfStatementStatementContext$Type): T
 "visitResourcelimit"(arg0: $SFMLParser$ResourcelimitContext$Type): T
 "visitForgetstatement"(arg0: $SFMLParser$ForgetstatementContext$Type): T
 "visitForgetStatementStatement"(arg0: $SFMLParser$ForgetStatementStatementContext$Type): T
 "visitIfstatement"(arg0: $SFMLParser$IfstatementContext$Type): T
 "visitInputstatement"(arg0: $SFMLParser$InputstatementContext$Type): T
 "visitBooleanConjunction"(arg0: $SFMLParser$BooleanConjunctionContext$Type): T
 "visitInputStatementStatement"(arg0: $SFMLParser$InputStatementStatementContext$Type): T
 "visitOutputStatementStatement"(arg0: $SFMLParser$OutputStatementStatementContext$Type): T
 "visitBooleanRedstone"(arg0: $SFMLParser$BooleanRedstoneContext$Type): T
 "visitBooleanNegation"(arg0: $SFMLParser$BooleanNegationContext$Type): T
 "visitResourcecomparison"(arg0: $SFMLParser$ResourcecomparisonContext$Type): T
 "visitQuantityRetentionLimit"(arg0: $SFMLParser$QuantityRetentionLimitContext$Type): T
 "visitRetentionLimit"(arg0: $SFMLParser$RetentionLimitContext$Type): T
 "visitBooleanDisjunction"(arg0: $SFMLParser$BooleanDisjunctionContext$Type): T
 "visitStringResource"(arg0: $SFMLParser$StringResourceContext$Type): T
 "visitQuantityLimit"(arg0: $SFMLParser$QuantityLimitContext$Type): T
 "visitQuantity"(arg0: $SFMLParser$QuantityContext$Type): T
 "visitBooleanTrue"(arg0: $SFMLParser$BooleanTrueContext$Type): T
 "visitNumber"(arg0: $SFMLParser$NumberContext$Type): T
 "visitRangeset"(arg0: $SFMLParser$RangesetContext$Type): T
 "visitRange"(arg0: $SFMLParser$RangeContext$Type): T
 "visitStringLabel"(arg0: $SFMLParser$StringLabelContext$Type): T
 "visitSlotqualifier"(arg0: $SFMLParser$SlotqualifierContext$Type): T
 "visitBlock"(arg0: $SFMLParser$BlockContext$Type): T
 "visitPulseTrigger"(arg0: $SFMLParser$PulseTriggerContext$Type): T
 "visitResourceLimitMovement"(arg0: $SFMLParser$ResourceLimitMovementContext$Type): T
 "visitOutputstatement"(arg0: $SFMLParser$OutputstatementContext$Type): T
 "visitResourceexclusion"(arg0: $SFMLParser$ResourceexclusionContext$Type): T
 "visitOutputmatchers"(arg0: $SFMLParser$OutputmatchersContext$Type): T
 "visitLabelaccess"(arg0: $SFMLParser$LabelaccessContext$Type): T
 "visitRetention"(arg0: $SFMLParser$RetentionContext$Type): T
 "visitProgram"(arg0: $SFMLParser$ProgramContext$Type): T
 "visitTimerTrigger"(arg0: $SFMLParser$TimerTriggerContext$Type): T
 "visitName"(arg0: $SFMLParser$NameContext$Type): T
 "visitTicks"(arg0: $SFMLParser$TicksContext$Type): T
 "visitTick"(arg0: $SFMLParser$TickContext$Type): T
 "visitSeconds"(arg0: $SFMLParser$SecondsContext$Type): T
 "visitLimitMovement"(arg0: $SFMLParser$LimitMovementContext$Type): T
 "visitInputmatchers"(arg0: $SFMLParser$InputmatchersContext$Type): T
 "visitEachSide"(arg0: $SFMLParser$EachSideContext$Type): T
 "visitSide"(arg0: $SFMLParser$SideContext$Type): T
 "visitBooleanHas"(arg0: $SFMLParser$BooleanHasContext$Type): T
 "visitListedSides"(arg0: $SFMLParser$ListedSidesContext$Type): T
 "visitRoundrobin"(arg0: $SFMLParser$RoundrobinContext$Type): T
 "visitBooleanFalse"(arg0: $SFMLParser$BooleanFalseContext$Type): T
 "visitBooleanParen"(arg0: $SFMLParser$BooleanParenContext$Type): T
 "visitResource"(arg0: $SFMLParser$ResourceContext$Type): T
 "visitComparisonOp"(arg0: $SFMLParser$ComparisonOpContext$Type): T
 "visitRawLabel"(arg0: $SFMLParser$RawLabelContext$Type): T
 "visitSetOp"(arg0: $SFMLParser$SetOpContext$Type): T
 "visit"(arg0: $ParseTree$Type): T
 "visitTerminal"(arg0: $TerminalNode$Type): T
 "visitErrorNode"(arg0: $ErrorNode$Type): T
 "visitChildren"(arg0: $RuleNode$Type): T
}

export namespace $SFMLVisitor {
const probejs$$marker: never
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLVisitor$Type<T> = ($SFMLVisitor<(T)>);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLVisitor_<T> = $SFMLVisitor$Type<(T)>;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$OutputStatementStatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$SFMLParser$OutputstatementContext, $SFMLParser$OutputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$OutputstatementContext"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$StatementContext, $SFMLParser$StatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StatementContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$OutputStatementStatementContext extends $SFMLParser$StatementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$StatementContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "outputstatement"(): $SFMLParser$OutputstatementContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$OutputStatementStatementContext$Type = ($SFMLParser$OutputStatementStatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$OutputStatementStatementContext_ = $SFMLParser$OutputStatementStatementContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity" {
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$TranslatableLogger, $TranslatableLogger$Type} from "packages/ca/teamdman/sfm/common/logging/$TranslatableLogger"
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 {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$Program, $Program$Type} from "packages/ca/teamdman/sfml/ast/$Program"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$ManagerBlockEntity$State, $ManagerBlockEntity$State$Type} from "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity$State"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$LockCode, $LockCode$Type} from "packages/net/minecraft/world/$LockCode"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$Level as $Level$0, $Level$Type as $Level$0$Type} from "packages/org/apache/logging/log4j/$Level"
import {$BaseContainerBlockEntity, $BaseContainerBlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BaseContainerBlockEntity"

export class $ManagerBlockEntity extends $BaseContainerBlockEntity {
static readonly "TICK_TIME_HISTORY_SIZE": integer
readonly "logger": $TranslatableLogger
 "lockKey": $LockCode

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

public "toString"(): string
public "getState"(): $ManagerBlockEntity$State
public "reset"(): void
public "getProgram"(): $Optional<($Program)>
public "setItem"(arg0: integer, arg1: $ItemStack$Type): void
public "getItem"(arg0: integer): $ItemStack
public "removeItemNoUpdate"(arg0: integer): $ItemStack
public "getContainerSize"(): integer
public static "serverTick"(arg0: $Level$Type, arg1: $BlockPos$Type, arg2: $BlockState$Type, arg3: $ManagerBlockEntity$Type): void
public "load"(arg0: $CompoundTag$Type): void
public "getMaxStackSize"(): integer
public "stillValid"(arg0: $Player$Type): boolean
public "canPlaceItem"(arg0: integer, arg1: $ItemStack$Type): boolean
public "getDisk"(): $Optional<($ItemStack)>
public "setProgram"(arg0: string): void
public "getTick"(): integer
public "sendUpdatePacket"(): void
public "getProgramString"(): $Optional<(string)>
public "setLogLevel"(arg0: $Level$0$Type): void
public "removeItem"(arg0: integer, arg1: integer): $ItemStack
public "isEmpty"(): boolean
public "clearContent"(): void
public "trackRedstonePulseUnprocessed"(): void
public "clearRedstonePulseQueue"(): void
public "rebuildProgramAndUpdateDisk"(): void
public "getUnprocessedRedstonePulseCount"(): integer
public "getReferencedLabels"(): $Set<(string)>
public "getTickTimeNanos"(): (long)[]
public static "stillValidBlockEntity"(arg0: $BlockEntity$Type, arg1: $Player$Type): boolean
public static "stillValidBlockEntity"(arg0: $BlockEntity$Type, arg1: $Player$Type, arg2: integer): boolean
public "setChanged"(): void
public static "tryClear"(arg0: any): void
get "state"(): $ManagerBlockEntity$State
get "program"(): $Optional<($Program)>
get "containerSize"(): integer
get "maxStackSize"(): integer
get "disk"(): $Optional<($ItemStack)>
set "program"(value: string)
get "tick"(): integer
get "programString"(): $Optional<(string)>
set "logLevel"(value: $Level$0$Type)
get "empty"(): boolean
get "unprocessedRedstonePulseCount"(): integer
get "referencedLabels"(): $Set<(string)>
get "tickTimeNanos"(): (long)[]
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $ManagerBlockEntity$Type = ($ManagerBlockEntity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $ManagerBlockEntity_ = $ManagerBlockEntity$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$SecondsContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$IntervalContext, $SFMLParser$IntervalContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$IntervalContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$SecondsContext extends $SFMLParser$IntervalContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$IntervalContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "SECONDS"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$SecondsContext$Type = ($SFMLParser$SecondsContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$SecondsContext_ = $SFMLParser$SecondsContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Side" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$Enum, $Enum$Type} from "packages/java/lang/$Enum"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $Side extends $Enum<($Side)> implements $ASTNode {
static readonly "TOP": $Side
static readonly "BOTTOM": $Side
static readonly "NORTH": $Side
static readonly "SOUTH": $Side
static readonly "EAST": $Side
static readonly "WEST": $Side


public static "values"(): ($Side)[]
public static "valueOf"(arg0: string): $Side
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Side$Type = (("east") | ("top") | ("south") | ("bottom") | ("north") | ("west")) | ($Side);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Side_ = $Side$Type;
}}
declare module "packages/ca/teamdman/sfm/common/item/$DiskItem" {
import {$TranslatableContents, $TranslatableContents$Type} from "packages/net/minecraft/network/chat/contents/$TranslatableContents"
import {$Component, $Component$Type} from "packages/net/minecraft/network/chat/$Component"
import {$UUID, $UUID$Type} from "packages/java/util/$UUID"
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 {$Program, $Program$Type} from "packages/ca/teamdman/sfml/ast/$Program"
import {$InteractionResultHolder, $InteractionResultHolder$Type} from "packages/net/minecraft/world/$InteractionResultHolder"
import {$TooltipFlag, $TooltipFlag$Type} from "packages/net/minecraft/world/item/$TooltipFlag"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$InteractionHand, $InteractionHand$Type} from "packages/net/minecraft/world/$InteractionHand"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Optional, $Optional$Type} from "packages/java/util/$Optional"
import {$ManagerBlockEntity, $ManagerBlockEntity$Type} from "packages/ca/teamdman/sfm/common/blockentity/$ManagerBlockEntity"
import {$Map, $Map$Type} from "packages/java/util/$Map"

export class $DiskItem 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()

public static "getProgram"(arg0: $ItemStack$Type): string
public static "getWarnings"(arg0: $ItemStack$Type): $List<($TranslatableContents)>
public static "getErrors"(arg0: $ItemStack$Type): $List<($TranslatableContents)>
public static "setWarnings"(arg0: $ItemStack$Type, arg1: $List$Type<($TranslatableContents$Type)>): void
public static "setProgram"(arg0: $ItemStack$Type, arg1: string): void
public static "setErrors"(arg0: $ItemStack$Type, arg1: $List$Type<($TranslatableContents$Type)>): void
public static "setProgramName"(arg0: $ItemStack$Type, arg1: string): void
public static "getProgramName"(arg0: $ItemStack$Type): string
public "use"(arg0: $Level$Type, arg1: $Player$Type, arg2: $InteractionHand$Type): $InteractionResultHolder<($ItemStack)>
public "getName"(arg0: $ItemStack$Type): $Component
public "appendHoverText"(arg0: $ItemStack$Type, arg1: $Level$Type, arg2: $List$Type<($Component$Type)>, arg3: $TooltipFlag$Type): void
public static "compileAndUpdateErrorsAndWarnings"(arg0: $ItemStack$Type, arg1: $ManagerBlockEntity$Type): $Optional<($Program)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $DiskItem$Type = ($DiskItem);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $DiskItem_ = $DiskItem$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ResourcecomparisonContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$NumberContext, $SFMLParser$NumberContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$NumberContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$ResourceidContext, $SFMLParser$ResourceidContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ResourceidContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$ComparisonOpContext, $SFMLParser$ComparisonOpContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$ComparisonOpContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ResourcecomparisonContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "number"(): $SFMLParser$NumberContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "comparisonOp"(): $SFMLParser$ComparisonOpContext
public "resourceid"(): $SFMLParser$ResourceidContext
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ResourcecomparisonContext$Type = ($SFMLParser$ResourcecomparisonContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ResourcecomparisonContext_ = $SFMLParser$ResourcecomparisonContext$Type;
}}
declare module "packages/ca/teamdman/sfml/ast/$Number" {
import {$Statement, $Statement$Type} from "packages/ca/teamdman/sfml/ast/$Statement"
import {$ResourceIdentifier, $ResourceIdentifier$Type} from "packages/ca/teamdman/sfml/ast/$ResourceIdentifier"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$ASTNode, $ASTNode$Type} from "packages/ca/teamdman/sfml/ast/$ASTNode"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Stream, $Stream$Type} from "packages/java/util/stream/$Stream"

export class $Number extends $Record implements $ASTNode {

constructor(value: long)

public "add"(arg0: $Number$Type): $Number
public "value"(): long
public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "getStatements"(): $List<($Statement)>
public "getReferencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
public "getDescendantStatements"(): $Stream<($Statement)>
get "statements"(): $List<($Statement)>
get "referencedIOResourceIds"(): $Stream<($ResourceIdentifier<(any), (any), (any)>)>
get "descendantStatements"(): $Stream<($Statement)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $Number$Type = ($Number);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $Number_ = $Number$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BlockContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$StatementContext, $SFMLParser$StatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StatementContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BlockContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "statement"(): $List<($SFMLParser$StatementContext)>
public "statement"(arg0: integer): $SFMLParser$StatementContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BlockContext$Type = ($SFMLParser$BlockContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BlockContext_ = $SFMLParser$BlockContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$IntervalContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$IntervalContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "copyFrom"(arg0: $SFMLParser$IntervalContext$Type): void
public "getRuleIndex"(): integer
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$IntervalContext$Type = ($SFMLParser$IntervalContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$IntervalContext_ = $SFMLParser$IntervalContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$BooleanParenContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$BooleanParenContext extends $SFMLParser$BoolexprContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$BoolexprContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "LPAREN"(): $TerminalNode
public "RPAREN"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "boolexpr"(): $SFMLParser$BoolexprContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$BooleanParenContext$Type = ($SFMLParser$BooleanParenContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$BooleanParenContext_ = $SFMLParser$BooleanParenContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/recipe/$PrintingPressRecipe" {
import {$InputReplacement, $InputReplacement$Type} from "packages/dev/latvian/mods/kubejs/recipe/$InputReplacement"
import {$RecipeSerializer, $RecipeSerializer$Type} from "packages/net/minecraft/world/item/crafting/$RecipeSerializer"
import {$NonNullList, $NonNullList$Type} from "packages/net/minecraft/core/$NonNullList"
import {$RecipeSchema, $RecipeSchema$Type} from "packages/dev/latvian/mods/kubejs/recipe/schema/$RecipeSchema"
import {$PrintingPressBlockEntity, $PrintingPressBlockEntity$Type} from "packages/ca/teamdman/sfm/common/blockentity/$PrintingPressBlockEntity"
import {$Ingredient, $Ingredient$Type} from "packages/net/minecraft/world/item/crafting/$Ingredient"
import {$Level, $Level$Type} from "packages/net/minecraft/world/level/$Level"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$ResourceLocation, $ResourceLocation$Type} from "packages/net/minecraft/resources/$ResourceLocation"
import {$Recipe, $Recipe$Type} from "packages/net/minecraft/world/item/crafting/$Recipe"
import {$RegistryAccess, $RegistryAccess$Type} from "packages/net/minecraft/core/$RegistryAccess"
import {$ReplacementMatch, $ReplacementMatch$Type} from "packages/dev/latvian/mods/kubejs/recipe/$ReplacementMatch"
import {$OutputReplacement, $OutputReplacement$Type} from "packages/dev/latvian/mods/kubejs/recipe/$OutputReplacement"

export class $PrintingPressRecipe implements $Recipe<($PrintingPressBlockEntity)> {
readonly "ID": $ResourceLocation
readonly "FORM": $Ingredient
readonly "INK": $Ingredient
readonly "PAPER": $Ingredient

constructor(arg0: $ResourceLocation$Type, arg1: $Ingredient$Type, arg2: $Ingredient$Type, arg3: $Ingredient$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public "matches"(arg0: $PrintingPressBlockEntity$Type, arg1: $Level$Type): boolean
public "getResultItem"(arg0: $RegistryAccess$Type): $ItemStack
public "assemble"(arg0: $PrintingPressBlockEntity$Type, arg1: $RegistryAccess$Type): $ItemStack
public "getSerializer"(): $RecipeSerializer<(any)>
public "canCraftInDimensions"(arg0: integer, arg1: integer): boolean
public "getId"(): $ResourceLocation
public "showNotification"(): boolean
public "getToastSymbol"(): $ItemStack
public "getIngredients"(): $NonNullList<($Ingredient)>
public "getRemainingItems"(arg0: $PrintingPressBlockEntity$Type): $NonNullList<($ItemStack)>
public "isIncomplete"(): boolean
public "isSpecial"(): boolean
public "getMod"(): string
public "getType"(): $ResourceLocation
public "replaceInput"(match: $ReplacementMatch$Type, arg1: $InputReplacement$Type): boolean
public "hasInput"(match: $ReplacementMatch$Type): boolean
public "getSchema"(): $RecipeSchema
public "getOrCreateId"(): $ResourceLocation
public "hasOutput"(match: $ReplacementMatch$Type): boolean
public "replaceOutput"(match: $ReplacementMatch$Type, arg1: $OutputReplacement$Type): boolean
public "getGroup"(): string
public "setGroup"(group: string): void
get "serializer"(): $RecipeSerializer<(any)>
get "id"(): $ResourceLocation
get "toastSymbol"(): $ItemStack
get "ingredients"(): $NonNullList<($Ingredient)>
get "incomplete"(): boolean
get "special"(): boolean
get "mod"(): string
get "type"(): $ResourceLocation
get "schema"(): $RecipeSchema
get "orCreateId"(): $ResourceLocation
get "group"(): string
set "group"(value: string)
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PrintingPressRecipe$Type = ($PrintingPressRecipe);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrintingPressRecipe_ = $PrintingPressRecipe$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$InputStatementStatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$StatementContext, $SFMLParser$StatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$StatementContext"
import {$SFMLParser$InputstatementContext, $SFMLParser$InputstatementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$InputstatementContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$InputStatementStatementContext extends $SFMLParser$StatementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$StatementContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "inputstatement"(): $SFMLParser$InputstatementContext
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$InputStatementStatementContext$Type = ($SFMLParser$InputStatementStatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$InputStatementStatementContext_ = $SFMLParser$InputStatementStatementContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$ListedSidesContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$SFMLParser$SidequalifierContext, $SFMLParser$SidequalifierContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SidequalifierContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$SFMLParser$SideContext, $SFMLParser$SideContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$SideContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$ListedSidesContext extends $SFMLParser$SidequalifierContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$SidequalifierContext$Type)

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "SIDE"(): $TerminalNode
public "side"(): $List<($SFMLParser$SideContext)>
public "side"(arg0: integer): $SFMLParser$SideContext
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "COMMA"(arg0: integer): $TerminalNode
public "COMMA"(): $List<($TerminalNode)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$ListedSidesContext$Type = ($SFMLParser$ListedSidesContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$ListedSidesContext_ = $SFMLParser$ListedSidesContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/logging/$TranslatableLogEvent" {
import {$TranslatableContents, $TranslatableContents$Type} from "packages/net/minecraft/network/chat/contents/$TranslatableContents"
import {$Record, $Record$Type} from "packages/java/lang/$Record"
import {$FriendlyByteBuf, $FriendlyByteBuf$Type} from "packages/net/minecraft/network/$FriendlyByteBuf"
import {$Instant, $Instant$Type} from "packages/org/apache/logging/log4j/core/time/$Instant"
import {$Level, $Level$Type} from "packages/org/apache/logging/log4j/$Level"

export class $TranslatableLogEvent extends $Record {

constructor(level: $Level$Type, instant: $Instant$Type, contents: $TranslatableContents$Type)

public "equals"(arg0: any): boolean
public "toString"(): string
public "hashCode"(): integer
public static "decode"(arg0: $FriendlyByteBuf$Type): $TranslatableLogEvent
public "encode"(arg0: $FriendlyByteBuf$Type): void
public "instant"(): $Instant
public "level"(): $Level
public "contents"(): $TranslatableContents
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $TranslatableLogEvent$Type = ($TranslatableLogEvent);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $TranslatableLogEvent_ = $TranslatableLogEvent$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$RoundrobinContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$RoundrobinContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "BY"(): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "BLOCK"(): $TerminalNode
public "LABEL"(): $TerminalNode
public "ROBIN"(): $TerminalNode
public "ROUND"(): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$RoundrobinContext$Type = ($SFMLParser$RoundrobinContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$RoundrobinContext_ = $SFMLParser$RoundrobinContext$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$IfstatementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$SFMLParser$BlockContext, $SFMLParser$BlockContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BlockContext"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$SFMLParser$BoolexprContext, $SFMLParser$BoolexprContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$BoolexprContext"
import {$List, $List$Type} from "packages/java/util/$List"
import {$TerminalNode, $TerminalNode$Type} from "packages/org/antlr/v4/runtime/tree/$TerminalNode"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$IfstatementContext extends $ParserRuleContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

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

public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "block"(arg0: integer): $SFMLParser$BlockContext
public "block"(): $List<($SFMLParser$BlockContext)>
public "END"(): $TerminalNode
public "IF"(): $List<($TerminalNode)>
public "IF"(arg0: integer): $TerminalNode
public "ELSE"(): $List<($TerminalNode)>
public "ELSE"(arg0: integer): $TerminalNode
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
public "getRuleIndex"(): integer
public "boolexpr"(): $List<($SFMLParser$BoolexprContext)>
public "boolexpr"(arg0: integer): $SFMLParser$BoolexprContext
public "THEN"(): $List<($TerminalNode)>
public "THEN"(arg0: integer): $TerminalNode
get "ruleIndex"(): integer
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$IfstatementContext$Type = ($SFMLParser$IfstatementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$IfstatementContext_ = $SFMLParser$IfstatementContext$Type;
}}
declare module "packages/ca/teamdman/sfm/common/blockentity/$PrintingPressBlockEntity" {
import {$LazyOptional, $LazyOptional$Type} from "packages/net/minecraftforge/common/util/$LazyOptional"
import {$CompoundTag, $CompoundTag$Type} from "packages/net/minecraft/nbt/$CompoundTag"
import {$Connection, $Connection$Type} from "packages/net/minecraft/network/$Connection"
import {$Packet, $Packet$Type} from "packages/net/minecraft/network/protocol/$Packet"
import {$Predicate, $Predicate$Type} from "packages/java/util/function/$Predicate"
import {$Direction, $Direction$Type} from "packages/net/minecraft/core/$Direction"
import {$Ingredient, $Ingredient$Type} from "packages/net/minecraft/world/item/crafting/$Ingredient"
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 {$ClientboundBlockEntityDataPacket, $ClientboundBlockEntityDataPacket$Type} from "packages/net/minecraft/network/protocol/game/$ClientboundBlockEntityDataPacket"
import {$ItemStack, $ItemStack$Type} from "packages/net/minecraft/world/item/$ItemStack"
import {$BlockContainerJS, $BlockContainerJS$Type} from "packages/dev/latvian/mods/kubejs/level/$BlockContainerJS"
import {$Capability, $Capability$Type} from "packages/net/minecraftforge/common/capabilities/$Capability"
import {$Item, $Item$Type} from "packages/net/minecraft/world/item/$Item"
import {$ClientGamePacketListener, $ClientGamePacketListener$Type} from "packages/net/minecraft/network/protocol/game/$ClientGamePacketListener"
import {$Player, $Player$Type} from "packages/net/minecraft/world/entity/player/$Player"
import {$Set, $Set$Type} from "packages/java/util/$Set"
import {$BlockEntity, $BlockEntity$Type} from "packages/net/minecraft/world/level/block/entity/$BlockEntity"
import {$List, $List$Type} from "packages/java/util/$List"
import {$Container, $Container$Type} from "packages/net/minecraft/world/$Container"
import {$BlockPos, $BlockPos$Type} from "packages/net/minecraft/core/$BlockPos"
import {$NotContainer, $NotContainer$Type} from "packages/ca/teamdman/sfm/common/recipe/$NotContainer"

export class $PrintingPressBlockEntity extends $BlockEntity implements $NotContainer {

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

public "getCapability"<T>(arg0: $Capability$Type<(T)>, arg1: $Direction$Type): $LazyOptional<(T)>
public "onDataPacket"(arg0: $Connection$Type, arg1: $ClientboundBlockEntityDataPacket$Type): void
public "getUpdateTag"(): $CompoundTag
public "getUpdatePacket"(): $Packet<($ClientGamePacketListener)>
public "load"(arg0: $CompoundTag$Type): void
public "getStacksToDrop"(): ($ItemStack)[]
public "acceptStack"(arg0: $ItemStack$Type): $ItemStack
public "performPrint"(): void
public "getForm"(): $ItemStack
public "getPaper"(): $ItemStack
public "getInk"(): $ItemStack
public "setItem"(arg0: integer, arg1: $ItemStack$Type): void
public "getItem"(arg0: integer): $ItemStack
public "removeItemNoUpdate"(arg0: integer): $ItemStack
public "getContainerSize"(): integer
public "getMaxStackSize"(): integer
public "startOpen"(arg0: $Player$Type): void
public "stopOpen"(arg0: $Player$Type): void
public "stillValid"(arg0: $Player$Type): boolean
public "canPlaceItem"(arg0: integer, arg1: $ItemStack$Type): boolean
public "hasAnyOf"(arg0: $Set$Type<($Item$Type)>): boolean
public "countItem"(arg0: $Item$Type): integer
public "hasAnyMatching"(arg0: $Predicate$Type<($ItemStack$Type)>): boolean
public "setChanged"(): void
public "removeItem"(arg0: integer, arg1: integer): $ItemStack
public "isEmpty"(): boolean
public "clearContent"(): void
public "kjs$self"(): $Container
public "canTakeItem"(arg0: $Container$Type, arg1: integer, arg2: $ItemStack$Type): boolean
public "isMutable"(): boolean
public "extractItem"(slot: integer, amount: integer, simulate: boolean): $ItemStack
public "setStackInSlot"(slot: integer, stack: $ItemStack$Type): void
public "isItemValid"(slot: integer, stack: $ItemStack$Type): boolean
public "insertItem"(slot: integer, stack: $ItemStack$Type, simulate: boolean): $ItemStack
public static "stillValidBlockEntity"(arg0: $BlockEntity$Type, arg1: $Player$Type): boolean
public "getStackInSlot"(slot: integer): $ItemStack
public "getSlotLimit"(slot: integer): integer
public "getSlots"(): integer
public static "stillValidBlockEntity"(arg0: $BlockEntity$Type, arg1: $Player$Type, arg2: integer): boolean
public "getHeight"(): integer
public "asContainer"(): $Container
public "setChanged"(): void
public "clear"(): void
public "getWidth"(): integer
public "getBlock"(level: $Level$Type): $BlockContainerJS
public static "tryClear"(arg0: any): void
public "isEmpty"(): boolean
public "insertItem"(stack: $ItemStack$Type, simulate: boolean): $ItemStack
public "getAllItems"(): $List<($ItemStack)>
public "count"(ingredient: $Ingredient$Type): integer
public "count"(): integer
public "find"(ingredient: $Ingredient$Type): integer
public "find"(): integer
public "countNonEmpty"(ingredient: $Ingredient$Type): integer
public "countNonEmpty"(): integer
public "clear"(ingredient: $Ingredient$Type): void
get "updateTag"(): $CompoundTag
get "updatePacket"(): $Packet<($ClientGamePacketListener)>
get "stacksToDrop"(): ($ItemStack)[]
get "form"(): $ItemStack
get "paper"(): $ItemStack
get "ink"(): $ItemStack
get "containerSize"(): integer
get "maxStackSize"(): integer
get "empty"(): boolean
get "mutable"(): boolean
get "slots"(): integer
get "height"(): integer
get "width"(): integer
get "empty"(): boolean
get "allItems"(): $List<($ItemStack)>
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $PrintingPressBlockEntity$Type = ($PrintingPressBlockEntity);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $PrintingPressBlockEntity_ = $PrintingPressBlockEntity$Type;
}}
declare module "packages/ca/teamdman/sfml/$SFMLParser$LimitMovementContext" {
import {$ParserRuleContext, $ParserRuleContext$Type} from "packages/org/antlr/v4/runtime/$ParserRuleContext"
import {$RecognitionException, $RecognitionException$Type} from "packages/org/antlr/v4/runtime/$RecognitionException"
import {$SFMLParser$MovementContext, $SFMLParser$MovementContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$MovementContext"
import {$ParseTreeVisitor, $ParseTreeVisitor$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeVisitor"
import {$Token, $Token$Type} from "packages/org/antlr/v4/runtime/$Token"
import {$ParseTree, $ParseTree$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTree"
import {$List, $List$Type} from "packages/java/util/$List"
import {$SFMLParser$LimitContext, $SFMLParser$LimitContext$Type} from "packages/ca/teamdman/sfml/$SFMLParser$LimitContext"
import {$ParseTreeListener, $ParseTreeListener$Type} from "packages/org/antlr/v4/runtime/tree/$ParseTreeListener"
import {$RuleContext, $RuleContext$Type} from "packages/org/antlr/v4/runtime/$RuleContext"

export class $SFMLParser$LimitMovementContext extends $SFMLParser$MovementContext {
 "children": $List<($ParseTree)>
 "start": $Token
 "stop": $Token
 "exception": $RecognitionException
static readonly "EMPTY": $ParserRuleContext
 "parent": $RuleContext
 "invokingState": integer

constructor(arg0: $SFMLParser$MovementContext$Type)

public "limit"(): $SFMLParser$LimitContext
public "accept"<T>(arg0: $ParseTreeVisitor$Type<(any)>): T
public "enterRule"(arg0: $ParseTreeListener$Type): void
public "exitRule"(arg0: $ParseTreeListener$Type): void
}
/**
 * Class-specific type exported by ProbeJS, use global Type_
 * types for convenience unless there's a naming conflict.
 */
export type $SFMLParser$LimitMovementContext$Type = ($SFMLParser$LimitMovementContext);
/**
 * Global type exported for convenience, use class-specific
 * types if there's a naming conflict.
 */
declare global {
export type $SFMLParser$LimitMovementContext_ = $SFMLParser$LimitMovementContext$Type;
}}
