@deafwave/osrs-botmaker-types 0.7.33 → 0.7.34

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

@@ -1,15 +1,12 @@
 
 
+/// <reference path="../../../runelite/index.d.ts" />
+
 declare namespace bot {
     /**
      * Interface for interacting with the player's equipped items
      * Provides methods to check and manage equipment
      */
-    type Item = {
-        id: number;
-        quantity: number;
-    };
-
     interface equipment {
         /**
          * Checks if the player has all the specified items equipped by their IDs
@@ -54,9 +51,16 @@ declare namespace bot {
         containsName: (name: string) => boolean;
 
         /**
-         * Gets an array of all currently equipped items
-         * @returns Array of equipped items
+         * Returns an array of all equipped items
+         * @returns Array of equipped items (net.runelite.api.Item)
+         */
+        getEquipment: () => net.runelite.api.Item[];
+
+        /**
+         * Unequips an item with the given ID from the equipment
+         * @param id The item ID to unequip
+         * @returns True if the item was unequipped, false otherwise
          */
-        getEquipment: () => Item[];
+        unequip: (id: number) => boolean;
     }
 }

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

@@ -12,7 +12,7 @@ declare namespace bot {
         /** Gets the quantity of the item being bought or sold */
         getQuantity(): number;
         /** Gets the slot number used for this exchange request */
-        getSlot(): GrandExchangeOffer;
+        getSlot(): net.runelite.api.GrandExchangeOffer;
         /** Checks if the request has been aborted */
         isAborted(): boolean;
         /** Checks if the request is in the process of being aborted */
@@ -25,6 +25,7 @@ declare namespace bot {
         setMaxAttempts(maxAttempts: number): void;
     }
 
+
     /**
      * Interface for interacting with the Grand Exchange
      * Provides methods to buy/sell items and check GE status
@@ -38,7 +39,7 @@ declare namespace bot {
          * @param walkToAndOpenGE Whether to automatically walk to and open the GE
          * @returns An ExchangeRequest object representing the buy order
          */
-        addBuyToQueue: (itemId: number, quantity: number, walkToAndOpenGE: boolean) => net.runelite.api.GrandExchangeOffer;
+        addBuyToQueue: (itemId: number, quantity: number, walkToAndOpenGE: boolean) => bot.ExchangeRequest;
 
         /**
          * Gets the current size of the Grand Exchange queue

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

@@ -61,6 +61,7 @@ declare namespace bot {
 		shop: bot.shop;
 		task: bot.task;
 		tileItems: bot.tileItems;
+		types: bot.types;
 		variables: bot.variables;
 		walking: bot.walking;
 		web: bot.web;

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

@@ -107,7 +107,7 @@ declare namespace bot {
          * @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;
+        castOnTileItem: (spellName: SpellName, tileItem: net.runelite.api.TileItem) => void;
 
         /**
          * Casts a magic spell on a tile object (game object in the world)

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

@@ -7,15 +7,23 @@ declare namespace bot {
      */
     interface net {
         /**
-         * Sends a message to specified targets via the network
-         * @param targetIds Array of target IDs to send the message to
+         * Sends a BotMaker message to the specified Discord IDs via the socket server
+         * @param targetIds Array of Discord 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
+         * Sends a BotMaker message to the specified RuneScape names via the socket server
+         * @param rsNames Array of RuneScape display names to send the message to
+         * @param message The message content to send
+         * @param includeSelf Whether to include the sender in the recipients
+         */
+        sendMessageToRsns: (rsNames: string[], message: string, includeSelf: boolean) => void;
+
+        /**
+         * Sends a BotMaker message to all nearby local players via the socket server
          * @param message The message content to send
          * @param includeSelf Whether to include the sender in the recipients
          */

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

@@ -7,9 +7,9 @@ declare namespace bot {
      */
     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)
+         * Enables the specified prayer. Use bypassMouseClicks to send the action without a click.
+         * @param prayer The Prayer enum value to enable
+         * @param bypassMouseClicks True to toggle without mouse clicks, false to use mouse clicks
          */
         togglePrayer: (prayer: net.runelite.api.Prayer, bypassMouseClicks: boolean) => void;
     }

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

@@ -2,8 +2,17 @@
 
 declare namespace bot {
     /**
-     * Information about a tile item (ground item)
+     * Result of finding the nearest reachable point (e.g. from findNearestPointAsync).
      */
+    interface NearestPointResult {
+        /** The nearest reachable world point */
+        getDestination: () => net.runelite.api.coords.WorldPoint;
+        getPathCost: () => number;
+        getPathDistance: () => number;
+        getStartPoint: () => net.runelite.api.coords.WorldPoint;
+        isFound: () => boolean;
+    }
+
     interface TileItemInfo {
         /** The tile where the item is located */
         tile: net.runelite.api.Tile;
@@ -65,4 +74,35 @@ declare namespace bot {
          */
         stop: () => void;
     }
+
+    interface types {
+        asActor: (obj: unknown) => net.runelite.api.Actor;
+        asExchangeRequest: (obj: unknown) => bot.ExchangeRequest;
+        asGraphicsObject: (obj: unknown) => net.runelite.api.GraphicsObject;
+        asGraphicsObjectArray: (obj: unknown) => net.runelite.api.GraphicsObject[];
+        asGrandExchangeOffer: (obj: unknown) => net.runelite.api.GrandExchangeOffer;
+        asHeadIcon: (obj: unknown) => net.runelite.api.HeadIcon;
+        asItem: (obj: unknown) => net.runelite.api.Item;
+        asItemArray: (obj: unknown) => net.runelite.api.Item[];
+        asNearestPointResult: (obj: unknown) => bot.NearestPointResult;
+        asNPC: (obj: unknown) => net.runelite.api.NPC;
+        asNPCArray: (obj: unknown) => net.runelite.api.NPC[];
+        asObjectComposition: (obj: unknown) => net.runelite.api.ObjectComposition;
+        asPlayer: (obj: unknown) => net.runelite.api.Player;
+        asPlayerArray: (obj: unknown) => net.runelite.api.Player[];
+        asPrayer: (obj: unknown) => net.runelite.api.Prayer;
+        asProjectile: (obj: unknown) => net.runelite.api.Projectile;
+        asProjectileArray: (obj: unknown) => net.runelite.api.Projectile[];
+        asTile: (obj: unknown) => net.runelite.api.Tile;
+        asTileItem: (obj: unknown) => net.runelite.api.TileItem;
+        asTileItemInfo: (obj: unknown) => bot.TileItemInfo;
+        asTileItemInfoArray: (obj: unknown) => bot.TileItemInfo[];
+        asTileObject: (obj: unknown) => net.runelite.api.TileObject;
+        asTileObjectArray: (obj: unknown) => net.runelite.api.TileObject[];
+        asWidget: (obj: unknown) => net.runelite.api.widgets.Widget;
+        asWidgetArray: (obj: unknown) => net.runelite.api.widgets.Widget[];
+        asWorldPoint: (obj: unknown) => net.runelite.api.coords.WorldPoint;
+        asWorldPointArray: (obj: unknown) => net.runelite.api.coords.WorldPoint[];
+        createWorldPoint: (x: number, y: number, plane: number) => net.runelite.api.coords.WorldPoint;
+    }
 }

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

@@ -9,43 +9,43 @@ declare namespace bot {
         /**
          * Gets a boolean variable by name
          * @param variableName The name of the variable to retrieve
-         * @returns The boolean value of the variable
+         * @returns The boolean value
          */
         getBooleanVariable: (variableName: string) => boolean;
 
         /**
          * Gets an array of integers variable by name
          * @param variableName The name of the variable to retrieve
-         * @returns The array of integers value of the variable
+         * @returns The integer array
          */
         getIntArrayVariable: (variableName: string) => number[];
 
         /**
          * Gets an integer variable by name
          * @param variableName The name of the variable to retrieve
-         * @returns The integer value of the variable
+         * @returns The integer value
          */
         getIntVariable: (variableName: string) => number;
 
         /**
          * Gets an array of strings variable by name
          * @param variableName The name of the variable to retrieve
-         * @returns The array of strings value of the variable
+         * @returns The string array
          */
         getStringArrayVariable: (variableName: string) => string[];
 
         /**
          * Gets a string variable by name
          * @param variableName The name of the variable to retrieve
-         * @returns The string value of the variable
+         * @returns The string value
          */
         getStringVariable: (variableName: string) => string;
 
         /**
          * Sets a variable of any type by name
          * @param variableName The name of the variable to set
-         * @param value The value to set the variable to
+         * @param value The value to set
          */
-        setVariable: (variableName: string, value: any) => void;
+        setVariable: (variableName: string, value: number | number[] | string | string[] | boolean) => void;
     }
 }

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

@@ -1,4 +1,5 @@
 /// <reference path="../../../runelite/index.d.ts" />
+/// <reference path="./types.d.ts" />
 
 declare namespace bot {
     /**
@@ -67,6 +68,22 @@ declare namespace bot {
          */
         webWalkToNearestBank: () => void;
 
+        /**
+         * Web walks to the nearest point from an array of destinations
+         * @param destinations Array of WorldPoint destinations to choose from
+         */
+        webWalkToNearest: (destinations: net.runelite.api.coords.WorldPoint[]) => void;
+
+        /**
+         * Finds the nearest reachable point from an array of destinations. Callback receives NearestPointResult (or null on error).
+         * @param destinations Array of WorldPoint destinations to choose from
+         * @param callback Called with the result or null on error
+         */
+        findNearestPointAsync: (
+            destinations: net.runelite.api.coords.WorldPoint[],
+            callback: (result: bot.NearestPointResult | null) => void
+        ) => void;
+
         /**
          * Starts web walking with full configuration options for food, stamina, teleports, and more
          * @param worldPoint The WorldPoint destination to walk to

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

@@ -1,15 +1,21 @@
 
 
-declare namespace bot {
+/// <reference path="../../../java/BufferedImage.d.ts" />
 
+declare namespace bot {
     interface web {
+        /**
+         * Fetches the content of the given URL as a string. Only allows http/https URLs from whitelisted domains. Returns an empty string on error.
+         * @param requestURL The URL to fetch
+         * @returns The response body as a string, or empty string on error
+         */
+        readString: (requestURL: string) => string;
 
         /**
-         * Reads a string from the web
-         * Whitelisted URLs: github.com, pastebin
-         * @param requestURL The URL to read the string from
-         * @returns The string read from the web
+         * Fetches an image from a whitelisted URL. Returns null on error.
+         * @param requestURL The URL to fetch the image from
+         * @returns The image as a BufferedImage, or null on error
          */
-        readString(requestURL: string): string;
+        readImage: (requestURL: string) => BufferedImage | null;
     }
 }

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

@@ -7,31 +7,41 @@ declare namespace bot {
      */
     interface widgets {
         /**
-         * Handles dialogue interactions
+         * Handles dialogue options by clicking continue or selecting from the provided dialogue options
+         * @param dialogues Array of dialogue option texts to select (for continue-only use e.g. [] or ["Continue"])
+         * @returns True if dialogue was handled, false otherwise
          */
-        handleDialogue: (dialogues: []) => boolean;
+        handleDialogue: (dialogues: string[]) => boolean;
 
         /**
-         * Interacts with a specified widget using its ID and parameters
-         * @param packedWidgetId The packed ID of the widget to interact with
-         * @param identifier The identifier for the interaction
-         * @param opcode The operation code for the interaction
-         * @param p0 The first parameter for the interaction
-         * @param p1 The second parameter for the interaction (optional)
+         * Interacts with a widget using packed widget ID, identifier, opcode, param0, and param1
          */
-
-        interactSpecifiedWidget: (
+        /**
+         * Interacts with a widget using packed widget ID, identifier, opcode, param0, and optionally param1.
+         * 
+         * @param packedWidgetId The packed widget ID
+         * @param identifier The identifier for the widget action
+         * @param opcode The opcode specifying the action
+         * @param param0 The first parameter for the action
+         * @param param1 (Optional) The second parameter for the action
+         */
+        interactSpecifiedWidget(
             packedWidgetId: number,
             identifier: number,
             opcode: number,
-            p0: number,
-            p1?: number
-        ) => void;
+            param0: number,
+            param1?: number
+        ): void;
 
         /**
-         * Interacts with a widget by matching its text content
+         * Interacts with a widget by matching its text content.
          * @param text The text to search for in widgets
          */
         interactWidgetText: (text: string) => void;
+
+        /**
+         * Enables special attack
+         */
+        enableSpecialAttack: () => void;
     }
 }

package/package.json

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