Interface SwarmBot

interface SwarmBot {
    _client: Client;
    acceptResourcePack: () => void;
    activateBlock: (
        block: Block,
        direction?: Vec3,
        cursorPos?: Vec3,
    ) => Promise<void>;
    activateEntity: (entity: Entity) => Promise<void>;
    activateEntityAt: (entity: Entity, position: Vec3) => Promise<void>;
    activateItem: (offhand?: boolean) => void;
    addChatPattern: (
        name: string,
        pattern: RegExp,
        options?: chatPatternOptions,
    ) => number;
    addChatPatternSet: (
        name: string,
        patterns: RegExp[],
        options?: chatPatternOptions,
    ) => number;
    attack: (entity: Entity) => void;
    awaitMessage: (...args: string[] | RegExp[]) => Promise<string>;
    blockAt: (point: Vec3, extraInfos?: boolean) => null | Block;
    blockAtCursor: (maxDistance?: number, matcher?: Function) => null | Block;
    blockAtEntityCursor: (
        entity?: Entity,
        maxDistance?: number,
        matcher?: Function,
    ) => null | Block;
    blockInSight: (maxSteps: number, vectorLength: number) => null | Block;
    canDigBlock: (block: Block) => boolean;
    canSeeBlock: (block: Block) => boolean;
    chat: (message: string) => void;
    chatAddPattern: (
        pattern: RegExp,
        chatType: string,
        description?: string,
    ) => number;
    chatPatterns: ChatPattern[];
    clearControlStates: () => void;
    clickWindow: (
        slot: number,
        mouseButton: number,
        mode: number,
    ) => Promise<void>;
    closeWindow: (window: Window) => void;
    connect: (options: BotOptions) => void;
    consume: () => Promise<void>;
    controlState: ControlStateStatus;
    craft: (
        recipe: Recipe,
        count?: number,
        craftingTable?: Block,
    ) => Promise<void>;
    creative: creativeMethods;
    currentWindow: null | Window<unknown>;
    deactivateItem: () => void;
    denyResourcePack: () => void;
    dig: (block: Block, forceLook?: boolean | "ignore") => Promise<void> & (
        block: Block,
        forceLook: boolean | "ignore",
        digFace: Vec3 | "auto" | "raycast",
    ) => Promise<void>;
    digTime: (block: Block) => number;
    dismount: () => void;
    elytraFly: () => Promise<void>;
    end: (reason?: string) => void;
    entities: { [id: string]: Entity };
    entity: Entity;
    entityAtCursor: (maxDistance?: number) => null | Entity;
    equip: (
        item: number | Item,
        destination: null | EquipmentDestination,
    ) => Promise<void>;
    experience: Experience;
    findBlock: (options: FindBlockOptions) => null | Block;
    findBlocks: (options: FindBlockOptions) => Vec3[];
    fireworkRocketDuration: number;
    fish: () => Promise<void>;
    food: number;
    foodSaturation: number;
    game: GameState;
    getControlState: (control: ControlState) => boolean;
    getEquipmentDestSlot: (destination: string) => number;
    getExplosionDamages: (
        targetEntity: Entity,
        position: Vec3,
        radius: number,
        rawDamages?: boolean,
    ) => null | number;
    hasPlugin: (plugin: Plugin) => boolean;
    health: number;
    heldItem: null | Item;
    inventory: Window<StorageEvents>;
    isABed: (bedBlock: Block) => boolean;
    isRaining: boolean;
    isSleeping: boolean;
    loadPlugin: (plugin: Plugin) => void;
    loadPlugins: (plugins: Plugin[]) => void;
    look: (yaw: number, pitch: number, force?: boolean) => Promise<void>;
    lookAt: (point: Vec3, force?: boolean) => Promise<void>;
    majorVersion: string;
    mount: (entity: Entity) => void;
    moveSlotItem: (sourceSlot: number, destSlot: number) => Promise<void>;
    moveVehicle: (left: number, forward: number) => void;
    nearestEntity: (filter?: (entity: Entity) => boolean) => null | Entity;
    openAnvil: (anvil: Block) => Promise<Anvil>;
    openBlock: (
        block: Block,
        direction?: Vec3,
        cursorPos?: Vec3,
    ) => Promise<Window<unknown>>;
    openChest: (
        chest: Entity | Block,
        direction?: number,
        cursorPos?: Vec3,
    ) => Promise<Chest>;
    openContainer: (
        chest: Entity | Block,
        direction?: Vec3,
        cursorPos?: Vec3,
    ) => Promise<Chest | Dispenser>;
    openDispenser: (dispenser: Block) => Promise<Dispenser>;
    openEnchantmentTable: (
        enchantmentTable: Block,
    ) => Promise<EnchantmentTable>;
    openEntity: (
        block: Entity,
        Class: new () => EventEmitter,
    ) => Promise<Window<unknown>>;
    openFurnace: (furnace: Block) => Promise<Furnace>;
    openVillager: (villager: Entity) => Promise<Villager>;
    oxygenLevel: number;
    physics: PhysicsOptions;
    physicsEnabled: boolean;
    placeBlock: (referenceBlock: Block, faceVector: Vec3) => Promise<void>;
    placeEntity: (referenceBlock: Block, faceVector: Vec3) => Promise<Entity>;
    player: Player;
    players: { [username: string]: Player };
    protocolVersion: string;
    putAway: (slot: number) => Promise<void>;
    putSelectedItemRange: (
        start: number,
        end: number,
        window: Window,
        slot: any,
    ) => Promise<void>;
    quickBarSlot: number;
    quit: (reason?: string) => void;
    recipesAll: (
        itemType: number,
        metadata: null | number,
        craftingTable: null | boolean | Block,
    ) => Recipe[];
    recipesFor: (
        itemType: number,
        metadata: null | number,
        minResultCount: null | number,
        craftingTable: null | boolean | Block,
    ) => Recipe[];
    registry: Registry;
    removeChatPattern: (name: string | number) => void;
    respawn: () => void;
    scoreboard: {
        "10": ScoreBoard;
        "11": ScoreBoard;
        "12": ScoreBoard;
        "13": ScoreBoard;
        "14": ScoreBoard;
        "15": ScoreBoard;
        "16": ScoreBoard;
        "17": ScoreBoard;
        "18": ScoreBoard;
        "3": ScoreBoard;
        "4": ScoreBoard;
        "5": ScoreBoard;
        "6": ScoreBoard;
        "7": ScoreBoard;
        "8": ScoreBoard;
        "9": ScoreBoard;
        belowName: ScoreBoard;
        list: ScoreBoard;
        sidebar: ScoreBoard;
    };
    scoreboards: { [name: string]: ScoreBoard };
    setCommandBlock: (
        pos: Vec3,
        command: string,
        options: CommandBlockOptions,
    ) => void;
    setControlState: (control: ControlState, state: boolean) => void;
    setQuickBarSlot: (slot: number) => void;
    setSettings: (options: Partial<GameSettings>) => void;
    settings: GameSettings;
    simpleClick: simpleClick;
    sleep: (bedBlock: Block) => Promise<void>;
    spawnPoint: Vec3;
    stopDigging: () => void;
    supportFeature: <T extends keyof SupportsFeature>(
        key: T,
    ) => SupportsFeature[T];
    swarmOptions?: BotSwarmData;
    swingArm: (hand: undefined | "left" | "right", showHand?: boolean) => void;
    tabComplete: (
        str: string,
        assumeCommand?: boolean,
        sendBlockInSight?: boolean,
        timeout?: number,
    ) => Promise<string[]>;
    tablist: Tablist;
    targetDigBlock: Block;
    teamMap: { [name: string]: Team };
    teams: { [name: string]: Team };
    thunderState: number;
    time: Time;
    toss: (
        itemType: number,
        metadata: null | number,
        count: null | number,
    ) => Promise<void>;
    tossStack: (item: Item) => Promise<void>;
    trade: (
        villagerInstance: Villager,
        tradeIndex: string | number,
        times?: number,
    ) => Promise<void>;
    transfer: (options: TransferOptions) => Promise<void>;
    unequip: (destination: null | EquipmentDestination) => Promise<void>;
    updateHeldItem: () => void;
    updateSign: (block: Block, text: string, back?: boolean) => void;
    useOn: (targetEntity: Entity) => void;
    username: string;
    usingHeldItem: boolean;
    version: string;
    waitForChunksToLoad: () => Promise<void>;
    waitForTicks: (ticks: number) => Promise<void>;
    wake: () => Promise<void>;
    whisper: (username: string, message: string) => void;
    world: WorldSync;
    writeBook: (slot: number, pages: string[]) => Promise<void>;
    addListener<E extends keyof BotEvents>(
        event: E,
        listener: BotEvents[E],
    ): this;
    emit<E extends keyof BotEvents>(
        event: E,
        ...args: Arguments<BotEvents[E]>,
    ): boolean;
    eventNames(): (string | symbol)[];
    getMaxListeners(): number;
    listenerCount<E extends keyof BotEvents>(event: E): number;
    listeners<E extends keyof BotEvents>(event: E): Function[];
    off<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this;
    on<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this;
    once<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this;
    prependListener<E extends keyof BotEvents>(
        event: E,
        listener: BotEvents[E],
    ): this;
    prependOnceListener<E extends keyof BotEvents>(
        event: E,
        listener: BotEvents[E],
    ): this;
    rawListeners<E extends keyof BotEvents>(event: E): Function[];
    removeAllListeners<E extends keyof BotEvents>(event?: E): this;
    removeListener<E extends keyof BotEvents>(
        event: E,
        listener: BotEvents[E],
    ): this;
    setMaxListeners(maxListeners: number): this;
}

Hierarchy

Bot
- SwarmBot

Index

Properties

_client acceptResourcePack activateBlock activateEntity activateEntityAt activateItem addChatPattern addChatPatternSet attack awaitMessage blockAt blockAtCursor blockAtEntityCursor blockInSight canDigBlock canSeeBlock chat chatAddPattern chatPatterns clearControlStates clickWindow closeWindow connect consume controlState craft creative currentWindow deactivateItem denyResourcePack dig digTime dismount elytraFly end entities entity entityAtCursor equip experience findBlock findBlocks fireworkRocketDuration fish food foodSaturation game getControlState getEquipmentDestSlot getExplosionDamages hasPlugin health heldItem inventory isABed isRaining isSleeping loadPlugin loadPlugins look lookAt majorVersion mount moveSlotItem moveVehicle nearestEntity openAnvil openBlock openChest openContainer openDispenser openEnchantmentTable openEntity openFurnace openVillager oxygenLevel physics physicsEnabled placeBlock placeEntity player players protocolVersion putAway putSelectedItemRange quickBarSlot quit recipesAll recipesFor registry removeChatPattern respawn scoreboard scoreboards setCommandBlock setControlState setQuickBarSlot setSettings settings simpleClick sleep spawnPoint stopDigging supportFeature swarmOptions? swingArm tabComplete tablist targetDigBlock teamMap teams thunderState time toss tossStack trade transfer unequip updateHeldItem updateSign useOn username usingHeldItem version waitForChunksToLoad waitForTicks wake whisper world writeBook

Methods

addListener emit eventNames getMaxListeners listenerCount listeners off on once prependListener prependOnceListener rawListeners removeAllListeners removeListener setMaxListeners

Properties

_client

_client: Client

acceptResourcePack

acceptResourcePack: () => void

activateBlock

activateBlock: (
    block: Block,
    direction?: Vec3,
    cursorPos?: Vec3,
) => Promise<void>

activateEntity

activateEntity: (entity: Entity) => Promise<void>

activateEntityAt

activateEntityAt: (entity: Entity, position: Vec3) => Promise<void>

activateItem

activateItem: (offhand?: boolean) => void

addChatPattern

addChatPattern: (
    name: string,
    pattern: RegExp,
    options?: chatPatternOptions,
) => number

addChatPatternSet

addChatPatternSet: (
    name: string,
    patterns: RegExp[],
    options?: chatPatternOptions,
) => number

attack

attack: (entity: Entity) => void

awaitMessage

awaitMessage: (...args: string[] | RegExp[]) => Promise<string>

blockAt

blockAt: (point: Vec3, extraInfos?: boolean) => null | Block

blockAtCursor

blockAtCursor: (maxDistance?: number, matcher?: Function) => null | Block

blockAtEntityCursor

blockAtEntityCursor: (
    entity?: Entity,
    maxDistance?: number,
    matcher?: Function,
) => null | Block

blockInSight

blockInSight: (maxSteps: number, vectorLength: number) => null | Block

canDigBlock

canDigBlock: (block: Block) => boolean

canSeeBlock

canSeeBlock: (block: Block) => boolean

chat

chat: (message: string) => void

chatAddPattern

chatAddPattern: (
    pattern: RegExp,
    chatType: string,
    description?: string,
) => number

chatPatterns

chatPatterns: ChatPattern[]

clearControlStates

clearControlStates: () => void

clickWindow

clickWindow: (slot: number, mouseButton: number, mode: number) => Promise<void>

closeWindow

closeWindow: (window: Window) => void

connect

connect: (options: BotOptions) => void

consume

consume: () => Promise<void>

controlState

controlState: ControlStateStatus

craft

craft: (recipe: Recipe, count?: number, craftingTable?: Block) => Promise<void>

creative

creative: creativeMethods

currentWindow

currentWindow: null | Window<unknown>

deactivateItem

deactivateItem: () => void

denyResourcePack

denyResourcePack: () => void

dig

dig: (block: Block, forceLook?: boolean | "ignore") => Promise<void> & (
    block: Block,
    forceLook: boolean | "ignore",
    digFace: Vec3 | "auto" | "raycast",
) => Promise<void>

digTime

digTime: (block: Block) => number

dismount

dismount: () => void

elytraFly

elytraFly: () => Promise<void>

end

end: (reason?: string) => void

entities

entities: { [id: string]: Entity }

entity

entity: Entity

entityAtCursor

entityAtCursor: (maxDistance?: number) => null | Entity

equip

equip: (
item: number | Item,
destination: null | EquipmentDestination,
) => Promise<void>

experience

experience: Experience

findBlock

findBlock: (options: FindBlockOptions) => null | Block

findBlocks

findBlocks: (options: FindBlockOptions) => Vec3[]

fireworkRocketDuration

fireworkRocketDuration: number

fish

fish: () => Promise<void>

food

food: number

foodSaturation

foodSaturation: number

game

game: GameState

getControlState

getControlState: (control: ControlState) => boolean

getEquipmentDestSlot

getEquipmentDestSlot: (destination: string) => number

getExplosionDamages

getExplosionDamages: (
    targetEntity: Entity,
    position: Vec3,
    radius: number,
    rawDamages?: boolean,
) => null | number

hasPlugin

hasPlugin: (plugin: Plugin) => boolean

health

health: number

heldItem

heldItem: null | Item

inventory

inventory: Window<StorageEvents>

isABed

isABed: (bedBlock: Block) => boolean

isRaining

isRaining: boolean

isSleeping

isSleeping: boolean

loadPlugin

loadPlugin: (plugin: Plugin) => void

loadPlugins

loadPlugins: (plugins: Plugin[]) => void

look

look: (yaw: number, pitch: number, force?: boolean) => Promise<void>

lookAt

lookAt: (point: Vec3, force?: boolean) => Promise<void>

majorVersion

majorVersion: string

mount

mount: (entity: Entity) => void

moveSlotItem

moveSlotItem: (sourceSlot: number, destSlot: number) => Promise<void>

moveVehicle

moveVehicle: (left: number, forward: number) => void

nearestEntity

nearestEntity: (filter?: (entity: Entity) => boolean) => null | Entity

openAnvil

openAnvil: (anvil: Block) => Promise<Anvil>

openBlock

openBlock: (
    block: Block,
    direction?: Vec3,
    cursorPos?: Vec3,
) => Promise<Window<unknown>>

openChest

openChest: (
    chest: Entity | Block,
    direction?: number,
    cursorPos?: Vec3,
) => Promise<Chest>

openContainer

openContainer: (
    chest: Entity | Block,
    direction?: Vec3,
    cursorPos?: Vec3,
) => Promise<Chest | Dispenser>

openDispenser

openDispenser: (dispenser: Block) => Promise<Dispenser>

openEnchantmentTable

openEnchantmentTable: (enchantmentTable: Block) => Promise<EnchantmentTable>

openEntity

openEntity: (
block: Entity,
Class: new () => EventEmitter,
) => Promise<Window<unknown>>

openFurnace

openFurnace: (furnace: Block) => Promise<Furnace>

openVillager

openVillager: (villager: Entity) => Promise<Villager>

oxygenLevel

oxygenLevel: number

physics

physics: PhysicsOptions

physicsEnabled

physicsEnabled: boolean

placeBlock

placeBlock: (referenceBlock: Block, faceVector: Vec3) => Promise<void>

placeEntity

placeEntity: (referenceBlock: Block, faceVector: Vec3) => Promise<Entity>

player

player: Player

players

players: { [username: string]: Player }

protocolVersion

protocolVersion: string

putAway

putAway: (slot: number) => Promise<void>

putSelectedItemRange

putSelectedItemRange: (
    start: number,
    end: number,
    window: Window,
    slot: any,
) => Promise<void>

quickBarSlot

quickBarSlot: number

quit

quit: (reason?: string) => void

recipesAll

recipesAll: (
    itemType: number,
    metadata: null | number,
    craftingTable: null | boolean | Block,
) => Recipe[]

recipesFor

recipesFor: (
    itemType: number,
    metadata: null | number,
    minResultCount: null | number,
    craftingTable: null | boolean | Block,
) => Recipe[]

registry

registry: Registry

removeChatPattern

removeChatPattern: (name: string | number) => void

respawn

respawn: () => void

scoreboard

scoreboard: {
    "10": ScoreBoard;
    "11": ScoreBoard;
    "12": ScoreBoard;
    "13": ScoreBoard;
    "14": ScoreBoard;
    "15": ScoreBoard;
    "16": ScoreBoard;
    "17": ScoreBoard;
    "18": ScoreBoard;
    "3": ScoreBoard;
    "4": ScoreBoard;
    "5": ScoreBoard;
    "6": ScoreBoard;
    "7": ScoreBoard;
    "8": ScoreBoard;
    "9": ScoreBoard;
    belowName: ScoreBoard;
    list: ScoreBoard;
    sidebar: ScoreBoard;
}

scoreboards

scoreboards: { [name: string]: ScoreBoard }

setCommandBlock

setCommandBlock: (
    pos: Vec3,
    command: string,
    options: CommandBlockOptions,
) => void

setControlState

setControlState: (control: ControlState, state: boolean) => void

setQuickBarSlot

setQuickBarSlot: (slot: number) => void

setSettings

setSettings: (options: Partial<GameSettings>) => void

settings

settings: GameSettings

simpleClick

simpleClick: simpleClick

sleep

sleep: (bedBlock: Block) => Promise<void>

spawnPoint

spawnPoint: Vec3

stopDigging

stopDigging: () => void

supportFeature

supportFeature: <T extends keyof SupportsFeature>(key: T) => SupportsFeature[T]

`Optional`swarmOptions

swarmOptions?: BotSwarmData

The bot's BotSwarmData.

swingArm

swingArm: (hand: undefined | "left" | "right", showHand?: boolean) => void

tabComplete

tabComplete: (
    str: string,
    assumeCommand?: boolean,
    sendBlockInSight?: boolean,
    timeout?: number,
) => Promise<string[]>

tablist

tablist: Tablist

targetDigBlock

targetDigBlock: Block

teamMap

teamMap: { [name: string]: Team }

teams

teams: { [name: string]: Team }

thunderState

thunderState: number

time

time: Time

toss

toss: (
    itemType: number,
    metadata: null | number,
    count: null | number,
) => Promise<void>

tossStack

tossStack: (item: Item) => Promise<void>

trade

trade: (
    villagerInstance: Villager,
    tradeIndex: string | number,
    times?: number,
) => Promise<void>

transfer

transfer: (options: TransferOptions) => Promise<void>

unequip

unequip: (destination: null | EquipmentDestination) => Promise<void>

updateHeldItem

updateHeldItem: () => void

updateSign

updateSign: (block: Block, text: string, back?: boolean) => void

useOn

useOn: (targetEntity: Entity) => void

username

username: string

usingHeldItem

usingHeldItem: boolean

version

version: string

waitForChunksToLoad

waitForChunksToLoad: () => Promise<void>

waitForTicks

waitForTicks: (ticks: number) => Promise<void>

wake

wake: () => Promise<void>

whisper

whisper: (username: string, message: string) => void

world

world: WorldSync

writeBook

writeBook: (slot: number, pages: string[]) => Promise<void>

Methods

addListener

addListener<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.addListener
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:24

emit

emit<E extends keyof BotEvents>(
event: E,
...args: Arguments<BotEvents[E]>,
): boolean
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- ...args: Arguments<BotEvents[E]>
Returns boolean
Inherited from Bot.emit
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:34

eventNames

eventNames(): (string | symbol)[]
Returns (string | symbol)[]
Inherited from Bot.eventNames
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:35

getMaxListeners

getMaxListeners(): number
Returns number
Inherited from Bot.getMaxListeners
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:40

listenerCount

listenerCount<E extends keyof BotEvents>(event: E): number
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
Returns number
Inherited from Bot.listenerCount
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:38

listeners

listeners<E extends keyof BotEvents>(event: E): Function[]
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
Returns Function[]
Inherited from Bot.listeners
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:37

off

off<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.off
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:30

on

on<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.on
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:25

once

once<E extends keyof BotEvents>(event: E, listener: BotEvents[E]): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.once
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:26

prependListener

prependListener<E extends keyof BotEvents>(
event: E,
listener: BotEvents[E],
): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.prependListener
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:27

prependOnceListener

prependOnceListener<E extends keyof BotEvents>(
event: E,
listener: BotEvents[E],
): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.prependOnceListener
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:28

rawListeners

rawListeners<E extends keyof BotEvents>(event: E): Function[]
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
Returns Function[]
Inherited from Bot.rawListeners
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:36

removeAllListeners

removeAllListeners<E extends keyof BotEvents>(event?: E): this
Type Parameters
- E extends keyof BotEvents
Parameters
- Optionalevent: E
Returns this
Inherited from Bot.removeAllListeners
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:31

removeListener

removeListener<E extends keyof BotEvents>(
event: E,
listener: BotEvents[E],
): this
Type Parameters
- E extends keyof BotEvents
Parameters
- event: E
- listener: BotEvents[E]
Returns this
Inherited from Bot.removeListener
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:32

setMaxListeners

setMaxListeners(maxListeners: number): this
Parameters
- maxListeners: number
Returns this
Inherited from Bot.setMaxListeners
- Defined in node_modules/mineflayer/node_modules/typed-emitter/index.d.ts:41