@deafwave/osrs-botmaker-types 0.7.18 → 0.7.19

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

@@ -0,0 +1,19 @@
+declare namespace bot {
+    /**
+     * Interface for Account Maker functionality
+     * Provides access to current objective and task information
+     */
+    interface accountMaker {
+        /**
+         * Gets the current Account Maker objective
+         * @returns The current objective. Uncaptured Sox type of com.theplug.plugins.accountmaker.config.impl.Objective 
+         */
+        getCurrentObjective: () => any;
+
+        /**
+         * Gets the current Account Maker task
+         * @returns The current task. Uncaptured Sox type of com.theplug.plugins.accountmaker.tasks.AbstractTask
+         */
+        getCurrentTask: () => any;
+    }
+}

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

@@ -1,12 +1,16 @@
 
-
 declare namespace bot {
+    /**
+     * Interface for managing attack styles
+     * Provides methods to set the player's attack style
+     */
     interface attackStyle {
         /**
-         * Sets the current attack style.
-         * @param attackstyle - The array of attack style IDs to set.
+         * Sets the attack style for the player. Accepts one or more styles as arguments.
+         * Valid styles are: 'Accurate', 'Aggressive', 'Controlled', 'Defensive', 'Longrange', 'Rapid'.
+         * Example: setStyle('Accurate', 'Aggressive')
+         * @param attackStyles Array of attack style names to set
          */
-        setStyle: (attackStyle: number[]) => void;
+        setStyle: (...attackStyles: ('Accurate' | 'Aggressive' | 'Controlled' | 'Defensive' | 'Longrange' | 'Rapid')[]) => void;
     }
-
 }

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

@@ -60,18 +60,18 @@ declare namespace bot {
         getNotedMode: () => boolean;
 
         /**
-         * Gets the quantities of all specified item IDs in the bank.
-         * @param itemIds - The array of item IDs to check.
-         * @returns An array of quantities corresponding to the provided item IDs.
+         * Returns the item quantities of all the given item IDs in the bank
+         * @param ids The array of item IDs to check
+         * @returns The total quantity of all specified items
          */
-        getQuantityOfAllIds: (itemIds: number[]) => number[];
+        getQuantityOfAllIds: (ids: number[]) => number;
 
         /**
-         * Gets the quantities of all specified item names in the bank.
-         * @param itemNames - The array of item names to check.
-         * @returns An array of quantities corresponding to the provided item names.
+         * Returns the item quantities of all the given item names in the bank
+         * @param names The array of item names to check
+         * @returns The total quantity of all specified items
          */
-        getQuantityOfAllNames: (itemNames: string[]) => number[];
+        getQuantityOfAllNames: (names: string[]) => number;
 
         /**
          * Gets the quantity of a specific item ID in the bank.

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

@@ -1,3 +1,5 @@
+/// <reference path="./accountMaker.d.ts" />
+/// <reference path="./attackStyle.d.ts" />
 /// <reference path="./bank.d.ts" />
 /// <reference path="./bmCache.d.ts" />
 /// <reference path="./bmGlobalCache.d.ts" />
@@ -18,6 +20,8 @@
 /// <reference path="./plugins.d.ts" />
 /// <reference path="./prayer.d.ts" />
 /// <reference path="./projectiles.d.ts" />
+/// <reference path="./sailing.d.ts" />
+/// <reference path="./shop.d.ts" />
 /// <reference path="./task.d.ts" />
 /// <reference path="./tileItems.d.ts" />
 /// <reference path="./types.d.ts" />
@@ -25,11 +29,14 @@
 /// <reference path="./walking.d.ts" />
 /// <reference path="./web.d.ts" />
 /// <reference path="./widgets.d.ts" />
+/// <reference path="../../../runelite/index.d.ts" />
+/// <reference path="../../java/awt/Rectangle.d.ts" />
 
 declare namespace bot {
 	// Core methods are accessed directly on the bot object
-	interface SoxBotApi extends bot {
+	interface SoxBotApi {
 		// Namespaces
+		accountMaker: bot.accountMaker;
 		attackStyle: bot.attackStyle;
 		bank: bot.bank;
 		bmCache: bot.bmCache;
@@ -50,6 +57,8 @@ declare namespace bot {
 		plugins: bot.plugins;
 		prayer: bot.prayer;
 		projectiles: bot.projectiles;
+		sailing: bot.sailing;
+		shop: bot.shop;
 		task: bot.task;
 		tileItems: bot.tileItems;
 		variables: bot.variables;
@@ -59,15 +68,31 @@ declare namespace bot {
 
 		// Direct methods
 		/**
-		 * Performs a menu action.
-		 * @param p0 The first parameter for the menu action
-		 * @param p1 The second parameter for the menu action
+		 * Terminates the execution of the current script
+		 */
+		terminate: () => void;
+
+		/**
+		 * Returns true if the local player has an animation of -1 and is not moving
+		 * @returns True if the local player is idle, false otherwise
+		 */
+		localPlayerIdle: () => boolean;
+
+		/**
+		 * Returns true if the local player is moving
+		 * @returns True if the local player is moving, false otherwise
+		 */
+		localPlayerMoving: () => boolean;
+
+		/**
+		 * Performs a MenuAction
+		 * @param p0 The first parameter
+		 * @param p1 The second parameter
 		 * @param action The menu action to perform
-		 * @param identifier The identifier for the menu action
-		 * @param itemId The item ID for the menu action
-		 * @param option The option for the menu action
-		 * @param target The target for the menu action
-		 * @param bounds The bounds for the menu action
+		 * @param identifier The identifier
+		 * @param itemId The item ID
+		 * @param option The option text
+		 * @param target The target text
 		 */
 		menuAction(
 			p0: number,
@@ -76,42 +101,105 @@ declare namespace bot {
 			identifier: number,
 			itemId: number,
 			option: string,
-			target: string,
-			bounds?: java.awt.Rectangle,
+			target: string
 		): void;
+
 		/**
-		 * Clears the game chat.
+		 * Performs a MenuAction with world view
+		 * @param p0 The first parameter
+		 * @param p1 The second parameter
+		 * @param action The menu action to perform
+		 * @param identifier The identifier
+		 * @param itemId The item ID
+		 * @param worldView The world view
+		 * @param option The option text
+		 * @param target The target text
 		 */
-		clearGameChat: () => void;
+		menuAction(
+			p0: number,
+			p1: number,
+			action: net.runelite.api.MenuAction,
+			identifier: number,
+			itemId: number,
+			worldView: number,
+			option: string,
+			target: string
+		): void;
+
 		/**
-		 * Checks if the local player is idle.
-		 * @returns True if the local player is idle, false otherwise.
+		 * Performs a MenuAction with the bounds of the given rectangle
+		 * @param p0 The first parameter
+		 * @param p1 The second parameter
+		 * @param action The menu action to perform
+		 * @param identifier The identifier
+		 * @param itemId The item ID
+		 * @param option The option text
+		 * @param target The target text
+		 * @param bounds The bounds rectangle
 		 */
-		localPlayerIdle: () => boolean;
+		menuAction(
+			p0: number,
+			p1: number,
+			action: net.runelite.api.MenuAction,
+			identifier: number,
+			itemId: number,
+			option: string,
+			target: string,
+			bounds: java.awt.Rectangle
+		): void;
+
 		/**
-		 * Checks if the local player is moving.
-		 * @returns True if the local player is moving, false otherwise.
+		 * Performs a MenuAction with world view and the bounds of the given rectangle
+		 * @param p0 The first parameter
+		 * @param p1 The second parameter
+		 * @param action The menu action to perform
+		 * @param identifier The identifier
+		 * @param itemId The item ID
+		 * @param worldView The world view
+		 * @param option The option text
+		 * @param target The target text
+		 * @param bounds The bounds rectangle
 		 */
-		localPlayerMoving: () => boolean;
+		menuAction(
+			p0: number,
+			p1: number,
+			action: net.runelite.api.MenuAction,
+			identifier: number,
+			itemId: number,
+			worldView: number,
+			option: string,
+			target: string,
+			bounds: java.awt.Rectangle
+		): void;
+
 		/**
-		 * Prints a message to the game chat.
-		 * @param message The message to print.
+		 * Prints a message in the bm logger
+		 * @param message The message to print
 		 */
-		printGameMessage: (message: string) => void;
+		printLogMessage: (message: string) => void;
+
 		/**
-		 * Prints a message to the log.
-		 * @param message The message to print.
+		 * Returns true if the local player has an animation of -1 and is not moving for a given number of ticks
+		 * @param ticks The number of ticks to check
+		 * @returns True if the local player has been idle for the specified ticks, false otherwise
 		 */
-		printLogMessage: (message: string) => void;
+		localPlayerIdleFor: (ticks: number) => boolean;
+
 		/**
-		 * Runs a client script.
-		 * @param ints The integer parameters for the script.
+		 * Clears the in game chat
+		 */
+		clearGameChat: () => void;
+
+		/**
+		 * Runs a client script
+		 * @param ints The integer parameters for the script
 		 */
 		runClientScript: (ints: number[]) => void;
 
 		/**
-		 * Terminates the bot.
+		 * Prints a message in game
+		 * @param message The message to print
 		 */
-		terminate: () => void;
+		printGameMessage: (message: string) => void;
 	}
 }

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

@@ -55,18 +55,18 @@ declare namespace bot {
         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
+         * Returns the total quantity of all items matching the given IDs in the inventory
+         * @param ids Array of item IDs to check
+         * @returns The total quantity of all specified items
          */
-        getQuantityOfAllIds: (itemIds: number[]) => number[];
+        getQuantityOfAllIds: (ids: 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
+         * Returns the total quantity of all items matching the given names in the inventory
+         * @param names Array of item names to check
+         * @returns The total quantity of all specified items
          */
-        getQuantityOfAllNames: (itemNames: string[]) => number[];
+        getQuantityOfAllNames: (names: string[]) => number;
 
         /**
          * Gets the quantity of an item with the specified ID
@@ -152,9 +152,9 @@ declare namespace bot {
         isFull: () => boolean;
 
         /**
-         * Gets all widgets in the inventory
+         * Returns an array of all inventory item widgets
          * @returns An array of all inventory widgets
          */
-        getAllWidgets(): net.runelite.api.widgets.Widget[];
+        getAllWidgets: () => net.runelite.api.widgets.Widget[];
     }
 }

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

@@ -0,0 +1,131 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Interface for managing boat sailing functionality
+     * Provides methods to control boat movement, speed, direction, and coordinate conversion
+     */
+    interface sailing {
+        /**
+         * Reverses the boat direction
+         * @returns True if the operation was successful, false otherwise
+         */
+        reverse: () => boolean;
+
+        /**
+         * Gets the current boat angle (0-1920)
+         * @returns The current boat angle
+         */
+        getBoatAngle: () => number;
+
+        /**
+         * Sets the sails to full speed (move mode 2)
+         * @returns True if the operation was successful, false otherwise
+         */
+        setSails: () => boolean;
+
+        /**
+         * Checks if the sails are currently set
+         * @returns True if the sails are set, false otherwise
+         */
+        isSailsSet: () => boolean;
+
+        /**
+         * Checks if the player is currently on a boat (in a separate world view)
+         * @returns True if the player is on a boat, false otherwise
+         */
+        isOnBoat: () => boolean;
+
+        /**
+         * Sets the sails using the GameObject on the boat (alternative method)
+         * @returns True if the operation was successful, false otherwise
+         */
+        setSailsObject: () => boolean;
+
+        /**
+         * Gets the current boat heading direction (0-15, where 0 is South and increases clockwise)
+         * @returns The current boat heading direction
+         */
+        getBoatHeading: () => number;
+
+        /**
+         * Lowers the boat speed (decreases move mode by 1)
+         * @returns True if the operation was successful, false otherwise
+         */
+        lowerSpeed: () => boolean;
+
+        /**
+         * Checks if the boat is in reverse (move mode 3)
+         * @returns True if the boat is in reverse, false otherwise
+         */
+        isReversing: () => boolean;
+
+        /**
+         * Raises the boat speed (increases move mode by 1)
+         * @returns True if the operation was successful, false otherwise
+         */
+        raiseSpeed: () => boolean;
+
+        /**
+         * Gets the current boat movement mode (0 = no movement, 1 = lower speed, 2 = full speed)
+         * @returns The current boat movement mode
+         */
+        getMovementSpeed: () => number;
+
+        /**
+         * Converts a WorldPoint from the boat's world view to main world coordinates
+         * @param boatWorldPoint The WorldPoint in the boat's world view
+         * @returns The converted WorldPoint in main world coordinates
+         */
+        convertToMainWorld: (boatWorldPoint: net.runelite.api.coords.WorldPoint) => net.runelite.api.coords.WorldPoint;
+
+        /**
+         * Checks if the boat is moving (move mode > 0)
+         * @returns True if the boat is moving, false otherwise
+         */
+        isBoatMoving: () => boolean;
+
+        /**
+         * Stops the boat completely
+         * @returns True if the operation was successful, false otherwise
+         */
+        stopBoat: () => boolean;
+
+        /**
+         * Unsets the sails to stop movement
+         * @returns True if the operation was successful, false otherwise
+         */
+        unsetSails: () => boolean;
+
+        /**
+         * Sets the heading direction of the boat (0-15, where 0 is south, clockwise)
+         * @param direction The heading direction to set (0-15)
+         * @returns True if the operation was successful, false otherwise
+         */
+        setHeading: (direction: number) => boolean;
+
+        /**
+         * Checks if the sailing control interface is available and visible
+         * @returns True if the sailing controls are available, false otherwise
+         */
+        isSailingControlsAvailable: () => boolean;
+
+        /**
+         * Gets the boat's center location in main world coordinates (center at scene 3,3)
+         * @returns The boat's center location as a WorldPoint
+         */
+        getBoatMainWorldLocation: () => net.runelite.api.coords.WorldPoint;
+
+        /**
+         * Gets the player's location in main world coordinates (useful when on a boat)
+         * @returns The player's location as a WorldPoint
+         */
+        getPlayerMainWorldLocation: () => net.runelite.api.coords.WorldPoint;
+
+        /**
+         * Gets the boat's center location with decimal precision [x, y]
+         * @returns Array containing the boat's center location coordinates [x, y]
+         */
+        getBoatMainWorldLocationFloats: () => number[];
+    }
+}

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

@@ -0,0 +1,43 @@
+declare namespace bot {
+    /**
+     * Interface for interacting with shops
+     * Provides methods to check shop status, buy items, and check stock
+     */
+    interface shop {
+        /**
+         * Checks if the shop interface is currently open
+         * @returns True if the shop is open, false otherwise
+         */
+        isOpen: () => boolean;
+
+        /**
+         * Gets the index of an item in the shop by its item ID
+         * @param itemId The item ID to find
+         * @returns The index of the item, or null if not found
+         */
+        getIndex: (itemId: number) => number | null;
+
+        /**
+         * Buys a specified quantity of an item from the shop by its item ID
+         * @param itemId The item ID to buy
+         * @param quantity The quantity to buy
+         * @returns True if the operation was successful, false otherwise
+         */
+        buy: (itemId: number, quantity: number) => boolean;
+
+        /**
+         * Checks if the shop has at least the specified quantity of an item by its item ID
+         * @param itemId The item ID to check
+         * @param quantity The minimum quantity to check for
+         * @returns True if the shop has at least the specified quantity, false otherwise
+         */
+        has: (itemId: number, quantity: number) => boolean;
+
+        /**
+         * Gets the current stock of a specific item in the shop by its item ID
+         * @param itemId The item ID to check
+         * @returns The current stock of the item
+         */
+        getStock: (itemId: number) => number;
+    }
+}

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

@@ -1,36 +1,16 @@
 
+/// <reference path="./types.d.ts" />
 
 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;
-
-        /**
-         * Sleep for a specified duration.
-         * @param duration - The duration to sleep in milliseconds.
-         */
-        sleep: (duration: number) => void;
-    }
-
-    /**
-     * Represents a factory for creating bot tasks.
+     * Interface for creating playable tasks
+     * Provides methods to create tasks that can chain functions with optional delays
      */
     interface task {
         /**
-         * Creates a new instance of a bot task.
-         * @returns A new botTask instance.
+         * Creates a new task object that can chain functions with optional delays in between
+         * @returns A new PlayableTask instance
          */
-        create: () => botTask;
+        create: () => PlayableTask;
     }
-}
+}

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

@@ -2,13 +2,6 @@
 /// <reference path="./types.d.ts" />
 
 declare namespace bot {
-
-    interface TileItemInfo {
-        id: number;
-        name: string;
-        quantity: number;
-        location: net.runelite.api.coords.WorldPoint;
-    }
     /**
      * Interface for interacting with items on the ground (tile items)
      * Provides methods to find and loot items from the ground
@@ -41,25 +34,29 @@ declare namespace bot {
          */
         lootItem: (tileItemInfo: TileItemInfo) => void;
 
+
         /**
-         * Loots all items of the specified minimum value within the maximum distance
-         * @param value The minimum value of items to loot
+         * Loots all items with the specified names within the maximum distance
+         * @param lootNames Array of item names to loot
          * @param maxDistance The maximum distance to loot items from
+         * @returns True if the operation was successful, false otherwise
          */
-        lootItemsOfValue: (value: number, maxDistance: number) => void;
+        lootItemsWithNames: (lootNames: string[], maxDistance: number) => boolean;
 
         /**
-         * Loots all items with the specified IDs within the maximum distance
+         * Loots the nearest ground item matching the given IDs within the max distance
          * @param lootIds Array of item IDs to loot
          * @param maxDistance The maximum distance to loot items from
+         * @returns True if the operation was successful, false otherwise
          */
-        lootItemsWithIds: (lootIds: number[], maxDistance: number) => void;
+        lootItemsWithIds: (lootIds: number[], maxDistance: number) => boolean;
 
         /**
-         * Loots all items with the specified names within the maximum distance
-         * @param lootNames Array of item names to loot
+         * Loots the nearest ground item of the given value or higher within the max distance
+         * @param value The minimum value of items to loot
          * @param maxDistance The maximum distance to loot items from
+         * @returns True if the operation was successful, false otherwise
          */
-        lootItemsWithNames: (lootNames: string[], maxDistance: number) => void;
+        lootItemsOfValue: (value: number, maxDistance: number) => boolean;
     }
 }

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

@@ -0,0 +1,68 @@
+/// <reference path="../../../runelite/index.d.ts" />
+
+declare namespace bot {
+    /**
+     * Information about a tile item (ground item)
+     */
+    interface TileItemInfo {
+        /** The tile where the item is located */
+        tile: net.runelite.api.Tile;
+        /** The tile item itself */
+        item: net.runelite.api.TileItem;
+
+        //** The name of the item */
+        getName: () => string;
+        /** Loots the item on the ground*/
+        loot: () => void;
+    }
+
+    /**
+     * A playable task that can chain functions with optional delays
+     */
+    interface PlayableTask {
+        /**
+         * Executes a callback action as part of the task.
+         * @param callback A function to execute in this task step
+         */
+        act: (callback: () => void) => void;
+
+        /**
+         * Loops the current task, repeating its actions.
+         */
+        /**
+         * Loops the current task a specific number of times, executing the provided callback function each iteration
+         * with a fixed delay between iterations.
+         * @param callback The function to execute on each iteration
+         * @param iterations The number of times to repeat the callback
+         * @param delayBetweenIterations The fixed delay (in milliseconds) between each iteration
+         */
+        loop: (callback: () => void, iterations: number, delayBetweenIterations: number) => void;
+        /**
+         * Loops the current task a specific number of times, executing the provided callback function each iteration,
+         * with a randomized delay between iterations ranging from delayBetweenIterations to maxDelayBetweenIterations.
+         * @param callback The function to execute on each iteration
+         * @param iterations The number of times to repeat the callback
+         * @param delayBetweenIterations The minimum delay (in milliseconds) between each iteration
+         * @param maxDelayBetweenIterations The maximum delay (in milliseconds) between each iteration
+         */
+        loop: (callback: () => void, iterations: number, delayBetweenIterations: number, maxDelayBetweenIterations: number) => void;
+
+        /**
+         * Pauses the current task for a specific number of milliseconds before continuing.
+         * @param milliseconds The exact number of milliseconds to sleep
+         */
+        sleep: (milliseconds : number) => void;
+
+        /**
+         * Pauses the current task for a random number of milliseconds between the provided minimum and maximum values before continuing.
+         * @param minMilliseconds The minimum number of milliseconds to sleep
+         * @param maxMilliseconds The maximum number of milliseconds to sleep
+         */
+        sleep: (minMilliseconds : number, maxMilliseconds : number) => void;
+
+        /**
+         * Stops the current task, preventing any further scheduled actions from executing.
+         */
+        stop: () => void;
+    }
+}

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

@@ -61,5 +61,43 @@ declare namespace bot {
          * @param worldPoint The WorldPoint destination to walk to
          */
         webWalkStart: (worldPoint: net.runelite.api.coords.WorldPoint) => void;
+
+        /**
+         * Web walks to the nearest bank
+         */
+        webWalkToNearestBank: () => void;
+
+        /**
+         * Starts web walking with full configuration options for food, stamina, teleports, and more
+         * @param worldPoint The WorldPoint destination to walk to
+         * @param eatFood Whether to eat food during the walk
+         * @param useStamina Whether to use stamina potions
+         * @param runEnergyMin Minimum run energy before stopping to rest
+         * @param useTransports Whether to use transport methods
+         * @param useTeleports Whether to use teleports
+         * @param useEquipmentJewellery Whether to use equipment jewellery for teleports
+         * @param useMinigameTeleports Whether to use minigame teleports
+         * @param avoidWilderness Whether to avoid the wilderness
+         * @param usePoh Whether to use Player Owned House
+         * @param useCharterShips Whether to use charter ships
+         */
+        webWalkStartWithConfig: (
+            worldPoint: net.runelite.api.coords.WorldPoint,
+            eatFood: boolean,
+            useStamina: boolean,
+            runEnergyMin: number,
+            useTransports: boolean,
+            useTeleports: boolean,
+            useEquipmentJewellery: boolean,
+            useMinigameTeleports: boolean,
+            avoidWilderness: boolean,
+            usePoh: boolean,
+            useCharterShips: boolean
+        ) => void;
+
+        /**
+         * Refreshes the available transports for web walking
+         */
+        refreshTransports: () => void;
     }
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deafwave/osrs-botmaker-types",
-  "version": "0.7.18",
+  "version": "0.7.19",
   "author": {
     "name": "Chandler Ferry",
     "url": "https://github.com/ChandlerFerry"