@deafwave/osrs-botmaker-types 0.3.8 → 0.4.1

package/dist/src/types/sox/api/bot/inventory.d.ts

@@ -0,0 +1,153 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for interacting with the player's inventory
+     * Provides methods to check inventory contents and use items
+     */
+    interface inventory {
+        /**
+         * Checks if the inventory contains all items with the specified IDs
+         * @param ids Array of item IDs to check for
+         * @returns True if all specified items are in the inventory, false otherwise
+         */
+        containsAllIds: (ids: number[]) => boolean;
+
+        /**
+         * Checks if the inventory contains all items with the specified names
+         * @param names Array of item names to check for
+         * @returns True if all specified items are in the inventory, false otherwise
+         */
+        containsAllNames: (names: string[]) => boolean;
+
+        /**
+         * Checks if the inventory contains any items with the specified IDs
+         * @param ids Array of item IDs to check for
+         * @returns True if any of the specified items are in the inventory, false otherwise
+         */
+        containsAnyIds: (ids: number[]) => boolean;
+
+        /**
+         * Checks if the inventory contains any items with the specified names
+         * @param names Array of item names to check for
+         * @returns True if any of the specified items are in the inventory, false otherwise
+         */
+        containsAnyNames: (names: string[]) => boolean;
+
+        /**
+         * Checks if the inventory contains an item with the specified ID
+         * @param id The item ID to check for
+         * @returns True if the item is in the inventory, false otherwise
+         */
+        containsId: (id: number) => boolean;
+
+        /**
+         * Checks if the inventory contains an item with the specified name
+         * @param name The item name to check for
+         * @returns True if the item is in the inventory, false otherwise
+         */
+        containsName: (name: string) => boolean;
+
+        /**
+         * Gets the number of empty slots in the inventory
+         * @returns The number of empty inventory slots
+         */
+        getEmptySlots: () => number;
+
+        /**
+         * Gets the quantities of all items with the specified IDs
+         * @param itemIds Array of item IDs to get quantities for
+         * @returns Array of quantities corresponding to the input IDs
+         */
+        getQuantityOfAllIds: (itemIds: number[]) => number[];
+
+        /**
+         * Gets the quantities of all items with the specified names
+         * @param itemNames Array of item names to get quantities for
+         * @returns Array of quantities corresponding to the input names
+         */
+        getQuantityOfAllNames: (itemNames: string[]) => number[];
+
+        /**
+         * Gets the quantity of an item with the specified ID
+         * @param itemId The item ID to get the quantity for
+         * @returns The quantity of the item in the inventory
+         */
+        getQuantityOfId: (itemId: number) => number;
+
+        /**
+         * Gets the quantity of an item with the specified name
+         * @param itemName The item name to get the quantity for
+         * @returns The quantity of the item in the inventory
+         */
+        getQuantityOfName: (itemName: string) => number;
+
+        /**
+         * Interacts with inventory items by their IDs
+         * @param itemIds Array of item IDs to interact with
+         * @param options Array of interaction options
+         */
+        interactWithIds: (itemIds: number[], options: string[]) => void;
+
+        /**
+         * Interacts with inventory items by their names
+         * @param itemNames Array of item names to interact with
+         * @param options Array of interaction options
+         */
+        interactWithNames: (itemNames: string[], options: string[]) => void;
+
+        /**
+         * Uses one inventory item on another by their IDs
+         * @param itemId1 The ID of the item to use
+         * @param itemId2 The ID of the item to use it on
+         */
+        itemOnItemWithIds: (itemId1: number, itemId2: number) => void;
+
+        /**
+         * Uses on inventory item on the last item in the inventory by its ID
+         * @param itemId1 The ID of the item to use
+         * @param lastItemId2 The ID of the last item in the inventory
+         */
+        itemOnLastItemWithIds: (itemId1: number, lastItemId2: number) => void;
+
+        /**
+         * Uses an inventory item on an NPC by the item's ID
+         * @param itemId The ID of the item to use
+         * @param npc The NPC to use the item on
+         */
+        itemOnNpcWithIds: (itemId: number, npc: net.runelite.api.NPC) => void;
+
+        /**
+         * Uses an inventory item on a tile object by the item's ID
+         * @param itemId The ID of the item to use
+         * @param tileObject The tile object to use the item on
+         */
+        itemOnObjectWithIds: (itemId: number, tileObject: net.runelite.api.TileObject) => void;
+
+        /**
+         * Uses an inventory item on a player by the item's ID
+         * @param itemId The ID of the item to use
+         * @param player The player to use the item on
+         */
+        itemOnPlayerWithIds: (itemId: number, player: net.runelite.api.Player) => void;
+
+        /**
+         * Uses an inventory item on a player by the item's name
+         * @param itemNames Array of item names to use
+         * @param playerNames Array of player names to use the item on
+         */
+        itemOnPlayerWithNames: (itemNames: string[], playerNames: string[]) => void;
+
+        /**
+         * Checks if the inventory is full
+         * @returns True if the inventory is full, false otherwise
+         */
+        isFull: () => boolean;
+
+        /**
+         * Gets all widgets in the inventory
+         * @returns An array of all inventory widgets
+         */
+        getAllWidgets(): net.runelite.api.widgets.Widget[];
+    }
+}

package/dist/src/types/sox/api/bot/magic.d.ts

@@ -0,0 +1,122 @@
+/// <reference path="../../../runelite/index.d.ts" />
+/// <reference path="./types.d.ts" />
+
+declare namespace bot {
+    /**
+     * Valid spell names that can be cast in the game
+     */
+    type SpellName =
+        // Standard spellbook teleports
+        | 'HOME_TELEPORT' | 'VARROCK_TELEPORT' | 'LUMBRIDGE_TELEPORT' | 'FALADOR_TELEPORT'
+        | 'TELEPORT_TO_HOUSE' | 'CAMELOT_TELEPORT' | 'ARDOUGNE_TELEPORT' | 'WATCHTOWER_TELEPORT'
+        | 'TROLLHEIM_TELEPORT' | 'TELEPORT_TO_APE_ATOLL' | 'TELEPORT_TO_KOUREND'
+        | 'TELEOTHER_LUMBRIDGE' | 'TELEOTHER_FALADOR' | 'TELEPORT_TO_BOUNTY_TARGET' | 'TELEOTHER_CAMELOT'
+        // Standard spellbook combat spells
+        | 'WIND_STRIKE' | 'WATER_STRIKE' | 'EARTH_STRIKE' | 'FIRE_STRIKE'
+        | 'WIND_BOLT' | 'WATER_BOLT' | 'EARTH_BOLT' | 'FIRE_BOLT'
+        | 'WIND_BLAST' | 'WATER_BLAST' | 'EARTH_BLAST' | 'FIRE_BLAST'
+        | 'WIND_WAVE' | 'WATER_WAVE' | 'EARTH_WAVE' | 'FIRE_WAVE'
+        | 'WIND_SURGE' | 'WATER_SURGE' | 'EARTH_SURGE' | 'FIRE_SURGE'
+        | 'SARADOMIN_STRIKE' | 'CLAWS_OF_GUTHIX' | 'FLAMES_OF_ZAMORAK'
+        | 'CRUMBLE_UNDEAD' | 'IBAN_BLAST' | 'MAGIC_DART'
+        // Standard spellbook other spells
+        | 'CONFUSE' | 'WEAKEN' | 'CURSE' | 'BIND' | 'SNARE' | 'VULNERABILITY'
+        | 'ENFEEBLE' | 'ENTANGLE' | 'STUN' | 'TELE_BLOCK' | 'CHARGE'
+        | 'BONES_TO_BANANAS' | 'LOW_LEVEL_ALCHEMY' | 'SUPERHEAT_ITEM' | 'HIGH_LEVEL_ALCHEMY' | 'BONES_TO_PEACHES'
+        | 'LVL_1_ENCHANT' | 'LVL_2_ENCHANT' | 'LVL_3_ENCHANT' | 'LVL_4_ENCHANT'
+        | 'LVL_5_ENCHANT' | 'LVL_6_ENCHANT' | 'LVL_7_ENCHANT'
+        | 'CHARGE_WATER_ORB' | 'CHARGE_EARTH_ORB' | 'CHARGE_FIRE_ORB' | 'CHARGE_AIR_ORB'
+        | 'TELEKINETIC_GRAB'
+        // Ancient spellbook
+        | 'EDGEVILLE_HOME_TELEPORT' | 'PADDEWWA_TELEPORT' | 'SENNTISTEN_TELEPORT' | 'KHARYRLL_TELEPORT'
+        | 'LASSAR_TELEPORT' | 'DAREEYAK_TELEPORT' | 'CARRALLANGER_TELEPORT' | 'BOUNTY_TARGET_TELEPORT'
+        | 'ANNAKARL_TELEPORT' | 'GHORROCK_TELEPORT'
+        | 'SMOKE_RUSH' | 'SHADOW_RUSH' | 'BLOOD_RUSH' | 'ICE_RUSH'
+        | 'SMOKE_BURST' | 'SHADOW_BURST' | 'BLOOD_BURST' | 'ICE_BURST'
+        | 'SMOKE_BLITZ' | 'SHADOW_BLITZ' | 'BLOOD_BLITZ' | 'ICE_BLITZ'
+        | 'SMOKE_BARRAGE' | 'SHADOW_BARRAGE' | 'BLOOD_BARRAGE' | 'ICE_BARRAGE'
+        // Lunar spellbook
+        | 'LUNAR_HOME_TELEPORT' | 'MOONCLAN_TELEPORT' | 'TELE_GROUP_MOONCLAN' | 'OURANIA_TELEPORT'
+        | 'WATERBIRTH_TELEPORT' | 'TELE_GROUP_WATERBIRTH' | 'BARBARIAN_TELEPORT' | 'TELE_GROUP_BARBARIAN'
+        | 'KHAZARD_TELEPORT' | 'TELE_GROUP_KHAZARD' | 'FISHING_GUILD_TELEPORT' | 'TELE_GROUP_FISHING_GUILD'
+        | 'CATHERBY_TELEPORT' | 'TELE_GROUP_CATHERBY' | 'ICE_PLATEAU_TELEPORT' | 'TELE_GROUP_ICE_PLATEAU'
+        | 'MONSTER_EXAMINE' | 'CURE_OTHER' | 'CURE_ME' | 'CURE_GROUP' | 'STAT_SPY' | 'DREAM'
+        | 'STAT_RESTORE_POT_SHARE' | 'BOOST_POTION_SHARE' | 'ENERGY_TRANSFER'
+        | 'HEAL_OTHER' | 'VENGEANCE_OTHER' | 'VENGEANCE' | 'HEAL_GROUP'
+        | 'BAKE_PIE' | 'GEOMANCY' | 'CURE_PLANT' | 'NPC_CONTACT' | 'HUMIDIFY'
+        | 'HUNTER_KIT' | 'SPIN_FLAX' | 'SUPERGLASS_MAKE' | 'TAN_LEATHER' | 'STRING_JEWELLERY'
+        | 'MAGIC_IMBUE' | 'FERTILE_SOIL' | 'PLANK_MAKE' | 'RECHARGE_DRAGONSTONE' | 'SPELLBOOK_SWAP'
+        // Arceuus spellbook
+        | 'ARCEUUS_HOME_TELEPORT' | 'ARCEUUS_LIBRARY_TELEPORT' | 'DRAYNOR_MANOR_TELEPORT' | 'BATTLEFRONT_TELEPORT'
+        | 'MIND_ALTAR_TELEPORT' | 'RESPAWN_TELEPORT' | 'SALVE_GRAVEYARD_TELEPORT' | 'FENKENSTRAINS_CASTLE_TELEPORT'
+        | 'WEST_ARDOUGNE_TELEPORT' | 'HARMONY_ISLAND_TELEPORT' | 'CEMETERY_TELEPORT' | 'BARROWS_TELEPORT'
+        | 'APE_ATOLL_TELEPORT'
+        | 'GHOSTLY_GRASP' | 'SKELETAL_GRASP' | 'UNDEAD_GRASP'
+        | 'INFERIOR_DEMONBANE' | 'SUPERIOR_DEMONBANE' | 'DARK_DEMONBANE'
+        | 'LESSER_CORRUPTION' | 'GREATER_CORRUPTION'
+        | 'RESURRECT_LESSER_GHOST' | 'RESURRECT_LESSER_SKELETON' | 'RESURRECT_LESSER_ZOMBIE'
+        | 'RESURRECT_SUPERIOR_GHOST' | 'RESURRECT_SUPERIOR_SKELETON' | 'RESURRECT_SUPERIOR_ZOMBIE'
+        | 'RESURRECT_GREATER_GHOST' | 'RESURRECT_GREATER_SKELETON' | 'RESURRECT_GREATER_ZOMBIE'
+        | 'DARK_LURE' | 'MARK_OF_DARKNESS' | 'WARD_OF_ARCEUUS'
+        | 'BASIC_REANIMATION' | 'ADEPT_REANIMATION' | 'EXPERT_REANIMATION' | 'MASTER_REANIMATION'
+        | 'DEMONIC_OFFERING' | 'SINISTER_OFFERING' | 'SHADOW_VEIL' | 'VILE_VIGOUR'
+        | 'DEGRIME' | 'RESURRECT_CROPS' | 'DEATH_CHARGE';
+
+    /**
+     * Interface for casting magic spells in the game
+     * Provides methods to cast spells on various targets
+     */
+    interface magic {
+        /**
+         * Casts a magic spell
+         * @param spellName The name of the spell to cast
+         * @param actionIndex Action index for the spell
+         */
+        cast: {
+            (spellName: SpellName): void;
+            (spellName: SpellName, actionIndex: number): void;
+        };
+
+        /**
+         * Casts a magic spell on an inventory item by its ID
+         * @param spellName The name of the spell to cast
+         * @param itemId The ID of the inventory item to cast the spell on
+         */
+        castOnInventoryItemId: (spellName: SpellName, itemId: number) => void;
+
+        /**
+         * Casts a magic spell on an inventory item by its name
+         * @param spellName The name of the spell to cast
+         * @param itemName The name of the inventory item to cast the spell on
+         */
+        castOnInventoryItemName: (spellName: SpellName, itemName: string) => void;
+
+        /**
+         * Casts a magic spell on an NPC
+         * @param spellName The name of the spell to cast
+         * @param npc The NPC to cast the spell on
+         */
+        castOnNpc: (spellName: SpellName, npc: net.runelite.api.NPC) => void;
+
+        /**
+         * Casts a magic spell on a player
+         * @param spellName The name of the spell to cast
+         * @param player The player to cast the spell on
+         */
+        castOnPlayer: (spellName: SpellName, player: net.runelite.api.Player) => void;
+
+        /**
+         * Casts a magic spell on a tile item (item on the ground)
+         * @param spellName The name of the spell to cast
+         * @param tileItem The tile item to cast the spell on
+         */
+        castOnTileItem: (spellName: SpellName, tileItem: bot.TileItemInfo) => void;
+
+        /**
+         * Casts a magic spell on a tile object (game object in the world)
+         * @param spellName The name of the spell to cast
+         * @param tileObject The tile object to cast the spell on
+         */
+        castOnTileObject: (spellName: SpellName, tileObject: net.runelite.api.TileObject) => void;
+    }
+}

package/dist/src/types/sox/api/bot/net.d.ts

@@ -0,0 +1,24 @@
+
+
+declare namespace bot {
+    /**
+     * Interface for network communication between bots
+     * Allows sending messages to other bots or players
+     */
+    interface net {
+        /**
+         * Sends a message to specified targets via the network
+         * @param targetIds Array of target IDs to send the message to
+         * @param message The message content to send
+         * @param includeSelf Whether to include the sender in the recipients
+         */
+        sendMessage: (targetIds: string[], message: string, includeSelf: boolean) => void;
+
+        /**
+         * Sends a message to local players
+         * @param message The message content to send
+         * @param includeSelf Whether to include the sender in the recipients
+         */
+        sendMessageToLocalPlayers: (message: string, includeSelf: boolean) => void;
+    }
+}

package/dist/src/types/sox/api/bot/notifier.d.ts

@@ -0,0 +1,16 @@
+
+
+declare namespace bot {
+    /**
+     * Interface for sending notifications
+     * Used to alert the user about important events
+     */
+    interface notifier {
+        /**
+         * Sends a notification message to the user
+         * This can trigger desktop notifications or other alerting mechanisms
+         * @param message The notification message to send
+         */
+        sendMessage: (message: string) => void;
+    }
+}

package/dist/src/types/sox/api/bot/npcs.d.ts

@@ -0,0 +1,89 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for interacting with NPCs (Non-Player Characters) in the game
+     * Provides methods to find and interact with NPCs
+     */
+    interface npcs {
+        /**
+         * Gets the current animation ID of an NPC
+         * @param npc The NPC to get the animation ID for
+         * @returns The animation ID of the NPC
+         */
+        getAnimationID: (npc: net.runelite.api.NPC) => number;
+
+        /**
+         * Gets the attack speed of an NPC type
+         * @param npcId The ID of the NPC type
+         * @returns The attack speed in game ticks
+         */
+        getAttackSpeed: (npcId: number) => number;
+
+        /**
+         * Gets the closest NPC from an array of NPCs
+         * @param npcs Array of NPCs to search
+         * @returns The closest NPC or null if none found
+         */
+        getClosest: (npcs: Array<net.runelite.api.NPC>) => net.runelite.api.NPC | null;
+
+        /**
+         * Gets the closest NPC within a maximum distance
+         * @param npcs Array of NPCs to search
+         * @param maxDistance The maximum distance to search within
+         * @returns The closest NPC within the specified distance or null if none found
+         */
+        getClosestWithin: (npcs: Array<net.runelite.api.NPC>, maxDistance: number) => net.runelite.api.NPC | null;
+
+        /**
+         * Gets the head icon of an NPC (such as prayer icons)
+         * @param npc The NPC to get the head icon for
+         * @returns The head icon of the NPC
+         */
+        getHeadIcon: (npc: net.runelite.api.NPC) => net.runelite.api.HeadIcon;
+
+        /**
+         * Gets all NPCs with the specified IDs
+         * @param ids Array of NPC IDs to search for
+         * @returns Array of matching NPC instances
+         */
+        getWithIds: (ids: number[]) => net.runelite.api.NPC[];
+
+        /**
+         * Gets all NPCs with the specified names
+         * @param names Array of NPC names to search for
+         * @returns Array of matching NPC instances
+         */
+        getWithNames: (names: string[]) => net.runelite.api.NPC[];
+
+        /**
+         * Interacts with an NPC by name and action
+         * @param npcName The name of the NPC to interact with
+         * @param action The interaction action to perform
+         */
+        interact: (npcName: string, action: string) => void;
+
+        /**
+         * Interacts with a supplied NPC instance
+         * @param target The NPC instance to interact with
+         * @param action The interaction action to perform
+         */
+        interactSupplied: (target: net.runelite.api.NPC, action: string) => void;
+
+        /**
+         * Checks if any NPCs with the specified IDs are within a certain distance
+         * @param ids Array of NPC IDs to check
+         * @param distance The maximum distance to check within
+         * @returns True if any NPCs are within the specified distance, false otherwise
+         */
+        isNearIds: (ids: number[], distance: number) => boolean;
+
+        /**
+         * Checks if any NPCs with the specified names are within a certain distance
+         * @param names Array of NPC names to check
+         * @param distance The maximum distance to check within
+         * @returns True if any NPCs are within the specified distance, false otherwise
+         */
+        isNearNames: (names: string[], distance: number) => boolean;
+    }
+}

package/dist/src/types/sox/api/bot/objects.d.ts

@@ -0,0 +1,89 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for interacting with game objects in the world
+     * Provides methods to find and interact with various objects
+     */
+    interface objects {
+        /**
+         * Gets the closest object from an array of tile objects
+         * @param tileObjects Array of tile objects to search through
+         * @returns The closest tile object to the player
+         */
+        getClosest: (tileObjects: net.runelite.api.TileObject[]) => net.runelite.api.TileObject;
+
+        /**
+         * Gets the closest object within a maximum distance
+         * @param tileObjects Array of tile objects to search through
+         * @param maxDistance The maximum distance to search within
+         * @returns The closest tile object within the specified distance
+         */
+        getClosestWithin: (tileObjects: net.runelite.api.TileObject[], maxDistance: number) => net.runelite.api.TileObject;
+
+        /**
+         * Gets the composition data for a tile object
+         * @param objectId The ID of the object to get composition for
+         * @returns The object composition data
+         */
+        getTileObjectComposition: (objectId: number) => net.runelite.api.ObjectComposition;
+
+        /**
+         * Gets all tile objects with the specified IDs
+         * @param ids Array of object IDs to search for
+         * @returns Array of matching tile objects
+         */
+        getTileObjectsWithIds: (ids: number[]) => net.runelite.api.TileObject[];
+
+        /**
+         * Gets all tile objects with the specified names
+         * @param names Array of object names to search for
+         * @returns Array of matching tile objects
+         */
+        getTileObjectsWithNames: (names: string[]) => net.runelite.api.TileObject[];
+
+        /**
+         * Gets all tile objects with the specified interaction options
+         * @param options Array of interaction options to search for
+         * @returns Array of matching tile objects
+         */
+        getTileObjectsWithOptions: (options: string[]) => net.runelite.api.TileObject[];
+
+        /**
+         * Interacts with an object by name
+         * @param objectName The name of the object to interact with
+         * @param action The interaction action to perform
+         */
+        interactObject: (objectName: string, action: string) => void;
+
+        /**
+         * Interacts with multiple objects by name
+         * @param objectNames Array of object names to interact with
+         * @param actions Array of interaction actions to perform
+         */
+        interactObjects: (objectNames: string[], actions: string[]) => void;
+
+        /**
+         * Interacts with a supplied object instance
+         * @param target The tile object instance to interact with
+         * @param action The interaction action to perform
+         */
+        interactSuppliedObject: (target: net.runelite.api.TileObject, action: string) => void;
+
+        /**
+         * Checks if objects with the specified IDs are near the player
+         * @param ids Array of object IDs to check for
+         * @param distance The maximum distance to check within
+         * @returns True if any matching objects are within the distance, false otherwise
+         */
+        isNearIds: (ids: number[], distance: number) => boolean;
+
+        /**
+         * Checks if objects with the specified names are near the player
+         * @param names Array of object names to check for
+         * @param distance The maximum distance to check within
+         * @returns True if any matching objects are within the distance, false otherwise
+         */
+        isNearNames: (names: string[], distance: number) => boolean;
+    }
+}

package/dist/src/types/sox/api/bot/players.d.ts

@@ -0,0 +1,35 @@
+
+
+declare namespace bot {
+    /**
+     * Interface for interacting with other players in the game
+     * Provides methods to interact with and check for other players
+     */
+    interface players {
+        /**
+         * Attacks a player by name
+         * @param names Array of player names to attack
+         */
+        attackPlayer: (names: string[]) => void;
+
+        /**
+         * Follows a player by name
+         * @param names Array of player names to follow
+         */
+        followPlayer: (names: string[]) => void;
+
+        /**
+         * Checks if a player is within a specified radius
+         * @param radius The radius to check within
+         * @param names Array of player names to check for
+         * @returns True if any matching players are within the radius, false otherwise
+         */
+        isNearPlayer: (radius: number, names: string[]) => boolean;
+
+        /**
+         * Initiates a trade with a player by name
+         * @param names Array of player names to trade with
+         */
+        tradePlayer: (names: string[]) => void;
+    }
+}

package/dist/src/types/sox/api/bot/plugins.d.ts

@@ -0,0 +1,81 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for the Quest Helper plugin
+     * Provides methods to assist with quest completion and navigation
+     */
+    interface questHelper {
+        /**
+         * Gets the name of the current quest being assisted
+         * @returns The name of the current quest
+         */
+        getCurrentQuestName: () => string;
+
+        /**
+         * Gets the next item(s) needed for the quest
+         * @returns An array containing information about the next required item(s)
+         */
+        getNextItem: () => any[];
+
+        /**
+         * Gets the next item-on-item interaction needed for the quest
+         * @returns Information about the next item-on-item interaction
+         * @todo ItemOnItem type definition
+         */
+        getNextItemOnItem: () => any;
+
+        /**
+         * Gets the next NPC to interact with for the quest
+         * @returns The next NPC object to interact with
+         */
+        getNextNpc: () => net.runelite.api.NPC;
+
+        /**
+         * Gets the next object to interact with for the quest
+         * @returns The next TileObject to interact with
+         */
+        getNextTileObject: () => net.runelite.api.TileObject;
+
+        /**
+         * Gets the next widget to interact with for the quest
+         * @returns The next Widget to interact with
+         */
+        getNextWidget: () => net.runelite.api.widgets.Widget;
+
+        /**
+         * Gets the next world point to navigate to for the quest
+         * @returns The next WorldPoint to navigate to
+         */
+        getNextWorldPoint: () => net.runelite.api.coords.WorldPoint;
+
+        /**
+         * Gets the overlay text shown by the quest helper
+         * @returns The current overlay text
+         */
+        getOverlayText: () => string;
+
+        /**
+         * Checks if the current quest has been started
+         * @returns True if the quest has been started, false otherwise
+         */
+        isQuestStarted: () => boolean;
+
+        /**
+         * Performs the next step in the quest
+         * @returns True if the next step was performed successfully, false otherwise
+         */
+        performNextStep: () => boolean;
+    }
+
+    /**
+     * Interface for accessing RuneLite plugins
+     * Provides access to plugin functionality like Quest Helper
+     */
+    interface plugins {
+        /**
+         * Access to the Quest Helper plugin functionality
+         */
+        questHelper: questHelper;
+    }
+}

package/dist/src/types/sox/api/bot/prayer.d.ts

@@ -0,0 +1,16 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for interacting with the prayer system
+     * Provides methods to toggle prayers on and off
+     */
+    interface prayer {
+        /**
+         * Toggles a prayer on or off
+         * @param prayer The Prayer enum value to toggle
+         * @param bypassMouseClicks Whether to bypass using mouse clicks and toggle directly (true) or use mouse clicks (false)
+         */
+        togglePrayer: (prayer: net.runelite.api.Prayer, bypassMouseClicks: boolean) => void;
+    }
+}

package/dist/src/types/sox/api/bot/projectiles.d.ts

@@ -0,0 +1,16 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for interacting with projectiles in the game
+     * Provides methods to retrieve information about active projectiles
+     */
+    interface projectiles {
+        /**
+         * Gets all projectiles that match the specified IDs
+         * @param ids Array of projectile IDs to match
+         * @returns Array of matching Projectile objects
+         */
+        getProjectilesWithIds: (ids: number[]) => net.runelite.api.Projectile[];
+    }
+}

package/dist/src/types/sox/api/bot/task.d.ts

@@ -0,0 +1,30 @@
+
+
+declare namespace bot {
+    /**
+     * Represents an instance of a bot task with actions and control methods.
+     */
+    interface botTask {
+        /**
+         * Executes the provided function as an action of the bot task.
+         * @param fn - The function to execute as part of the task's action.
+         */
+        act: (fn: () => void) => void;
+
+        /**
+         * Stops the execution of the bot task.
+         */
+        stop: () => void;
+    }
+
+    /**
+     * Represents a factory for creating bot tasks.
+     */
+    interface task {
+        /**
+         * Creates a new instance of a bot task.
+         * @returns A new botTask instance.
+         */
+        create: () => botTask;
+    }
+}