@deafwave/osrs-botmaker-types 0.2.12 → 0.3.0

package/dist/src/types/runelite/net/runelite/http/api/item/index.d.ts

@@ -0,0 +1,232 @@
+/// <reference path="../../../../../../../../src/types/java/index.d.ts" />
+/// <reference path="../../../../../../../../src/types/runelite/index.d.ts" />
+declare namespace net.runelite.http.api.item {
+	export class ItemEquipmentStats {
+		private slot: number;
+		private is2h: boolean;
+		private astab: number;
+		private aslash: number;
+		private acrush: number;
+		private amagic: number;
+		private arange: number;
+		private dstab: number;
+		private dslash: number;
+		private dcrush: number;
+		private dmagic: number;
+		private drange: number;
+		private str: number;
+		private rstr: number;
+		private mdmg: number;
+		private prayer: number;
+		private aspeed: number;
+
+		constructor(
+			slot: number,
+			isTwoHanded: boolean,
+			astab: number,
+			aslash: number,
+			acrush: number,
+			amagic: number,
+			arange: number,
+			dstab: number,
+			dslash: number,
+			dcrush: number,
+			dmagic: number,
+			drange: number,
+			str: number,
+			rstr: number,
+			mdmg: number,
+			prayer: number,
+			aspeed: number,
+		);
+
+		// public static builder(): ItemEquipmentStatsBuilder
+
+		public getSlot(): number;
+
+		public isTwoHanded(): boolean;
+
+		public getAstab(): number;
+
+		public getAslash(): number;
+
+		public getAcrush(): number;
+
+		public getAmagic(): number;
+
+		public getArange(): number;
+
+		public getDstab(): number;
+
+		public getDslash(): number;
+
+		public getDcrush(): number;
+
+		public getDmagic(): number;
+
+		public getDrange(): number;
+
+		public getStr(): number;
+
+		public getRstr(): number;
+
+		public getMdmg(): number;
+
+		public getPrayer(): number;
+
+		public getAspeed(): number;
+
+		public equals(o: Record<string, any>): boolean;
+
+		public hashCode(): number;
+
+		public toString(): string;
+
+		// public static class ItemEquipmentStatsBuilder {
+		//     private int slot;
+		//     private boolean isTwoHanded;
+		//     private int astab;
+		//     private int aslash;
+		//     private int acrush;
+		//     private int amagic;
+		//     private int arange;
+		//     private int dstab;
+		//     private int dslash;
+		//     private int dcrush;
+		//     private int dmagic;
+		//     private int drange;
+		//     private int str;
+		//     private int rstr;
+		//     private int mdmg;
+		//     private int prayer;
+		//     private int aspeed;
+
+		//     ItemEquipmentStatsBuilder() {
+		//     }
+
+		//     public ItemEquipmentStatsBuilder slot(int slot) {
+		//         this.slot = slot;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder isTwoHanded(boolean isTwoHanded) {
+		//         this.isTwoHanded = isTwoHanded;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder astab(int astab) {
+		//         this.astab = astab;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder aslash(int aslash) {
+		//         this.aslash = aslash;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder acrush(int acrush) {
+		//         this.acrush = acrush;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder amagic(int amagic) {
+		//         this.amagic = amagic;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder arange(int arange) {
+		//         this.arange = arange;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder dstab(int dstab) {
+		//         this.dstab = dstab;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder dslash(int dslash) {
+		//         this.dslash = dslash;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder dcrush(int dcrush) {
+		//         this.dcrush = dcrush;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder dmagic(int dmagic) {
+		//         this.dmagic = dmagic;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder drange(int drange) {
+		//         this.drange = drange;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder str(int str) {
+		//         this.str = str;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder rstr(int rstr) {
+		//         this.rstr = rstr;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder mdmg(int mdmg) {
+		//         this.mdmg = mdmg;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder prayer(int prayer) {
+		//         this.prayer = prayer;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStatsBuilder aspeed(int aspeed) {
+		//         this.aspeed = aspeed;
+		//         return this;
+		//     }
+
+		//     public ItemEquipmentStats build() {
+		//         return new ItemEquipmentStats(this.slot, this.isTwoHanded, this.astab, this.aslash, this.acrush, this.amagic, this.arange, this.dstab, this.dslash, this.dcrush, this.dmagic, this.drange, this.str, this.rstr, this.mdmg, this.prayer, this.aspeed);
+		//     }
+
+		//     public String toString() {
+		//         return "ItemEquipmentStats.ItemEquipmentStatsBuilder(slot=" + this.slot + ", isTwoHanded=" + this.isTwoHanded + ", astab=" + this.astab + ", aslash=" + this.aslash + ", acrush=" + this.acrush + ", amagic=" + this.amagic + ", arange=" + this.arange + ", dstab=" + this.dstab + ", dslash=" + this.dslash + ", dcrush=" + this.dcrush + ", dmagic=" + this.dmagic + ", drange=" + this.drange + ", str=" + this.str + ", rstr=" + this.rstr + ", mdmg=" + this.mdmg + ", prayer=" + this.prayer + ", aspeed=" + this.aspeed + ")";
+		//     }
+		// }
+	}
+
+	export class ItemStats {
+		private equipable: boolean;
+		private weight: number;
+		/** ge_limit? */
+		private geLimit: number;
+		private equipment: ItemEquipmentStats;
+
+		public subtract(other: ItemStats): ItemStats;
+
+		public ItemStats(
+			equipable: boolean,
+			weight: number,
+			geLimit: number,
+			equipment: ItemEquipmentStats,
+		);
+
+		public isEquipable(): boolean;
+
+		public getWeight(): number;
+
+		public getGeLimit(): number;
+
+		public getEquipment(): ItemEquipmentStats;
+
+		public equals(o: Record<string, any>): boolean;
+
+		public hashCode(): number;
+
+		public toString(): number;
+	}
+}

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

@@ -1,91 +1,115 @@
 /// <reference path="../../runelite/index.d.ts" />
 
+/** @deprecated Use bot */
 declare const api: SoxApi;
 
 interface SoxApi {
-	/** @deprecated see {@link printGameMessage}*/
-	PrintDebugMessage: (message: string) => void;
-
+	/** @deprecated */
 	attackPlayer: (names: string[]) => void;
+	/** @deprecated */
 	clearGameChat: () => void;
+	/** @deprecated */
 	depositAllToBankWithId: (id: number) => void;
+	/** @deprecated */
 	depositAllToBankWithName: (name: string) => void;
+	/** @deprecated */
 	depositToBankWithId: (id: number) => void;
+	/** @deprecated */
 	depositToBankWithName: (name: string) => void;
+	/** @deprecated */
 	followPlayer: (names: string[]) => void;
+	/** @deprecated */
 	getBooleanVariable: (variableName: string) => boolean;
+	/** @deprecated */
 	getCounter: (name: string) => number;
-	getGraphicsObjectsWithIds: (
-		ids: number[],
-	) => net.runelite.api.GraphicsObject[];
+	/** @deprecated */
+	getGraphicsObjectsWithIds: (ids: number[]) => net.runelite.api.GraphicsObject[];
+	/** @deprecated */
 	getIntArrayVariable: (variableName: string) => number[];
+	/** @deprecated */
 	getIntVariable: (variableName: string) => number;
+	/** @deprecated */
 	getNpcAttackSpeed: (npcId: number) => number;
+	/** @deprecated */
 	getNpcsWithIds: (ids: number[]) => net.runelite.api.NPC[];
+	/** @deprecated */
 	getNpcsWithNames: (names: string[]) => net.runelite.api.NPC[];
+	/** @deprecated */
 	getProjectilesWithIds: (ids: number[]) => net.runelite.api.Projectile[];
+	/** @deprecated */
 	getStringArrayVariable: (variableName: string) => string[];
+	/** @deprecated */
 	getStringVariable: (variableName: string) => string;
-	getTileObjectComposition: (
-		objectId: number,
-	) => net.runelite.api.ObjectComposition;
+	/** @deprecated */
+	getTileObjectComposition: (objectId: number) => net.runelite.api.ObjectComposition;
+	/** @deprecated */
 	getTileObjectsWithIds: (ids: number[]) => net.runelite.api.TileObject[];
+	/** @deprecated */
 	getTileObjectsWithNames: (names: string[]) => net.runelite.api.TileObject[];
-	interactInventoryItemOnNpcWithIds(
-		itemId: number,
-		npc: net.runelite.api.NPC,
-	): void;
-	interactInventoryItemOnObjectWithIds(
-		itemId: number,
-		tileObject: net.runelite.api.TileObject,
-	): void;
+	/** @deprecated */
+	interactInventoryItemOnNpcWithIds(itemId: number, npc: net.runelite.api.NPC): void;
+	/** @deprecated */
+	interactInventoryItemOnObjectWithIds(itemId: number, tileObject: net.runelite.api.TileObject): void;
+	/** @deprecated */
 	interactInventoryWithIds: (itemIds: number[], options: string[]) => void;
-	interactInventoryWithNames: (
-		itemNames: string[],
-		options: string[],
-	) => void;
+	/** @deprecated */
+	interactInventoryWithNames: (itemNames: string[], options: string[]) => void;
+	/** @deprecated */
 	interactNpc: (npcName: string, action: string) => void;
+	/** @deprecated */
 	interactObject: (objectName: string, action: string) => void;
+	/** @deprecated */
 	interactObjects: (objectName: string[], action: string[]) => void;
-	interactSpecifiedWidget(
-		pid: number,
-		id: number,
-		opcode: number,
-		param0: number,
-		param1?: number,
-	): void;
+	/** @deprecated */
+	interactSpecifiedWidget(pid: number, id: number, opcode: number, param0: number, param1?: number): void;
+	/** @deprecated */
 	interactSuppliedNpc: (target: net.runelite.api.NPC, action: string) => void;
-	interactSuppliedObject: (
-		target: net.runelite.api.TileObject,
-		action: string,
-	) => void;
+	/** @deprecated */
+	interactSuppliedObject: (target: net.runelite.api.TileObject, action: string) => void;
+	/** @deprecated */
 	interactWidgetText(text: string): void;
+	/** @deprecated */
 	isBankOpen: () => boolean;
+	/** @deprecated */
 	isNearPlayer: (radius: number, names: string[]) => boolean;
+	/** @deprecated */
 	isWebWalking: () => boolean;
+	/** @deprecated */
 	localPlayerIdle: () => boolean;
+	/** @deprecated */
 	localPlayerMoving: () => boolean;
+	/** @deprecated */
 	lootItemsWithIds: (lootIds: number[], maxDistance: number) => void;
+	/** @deprecated */
 	lootItemsWithNames: (lootNames: string[], maxDistance: number) => void;
+	/** @deprecated */
 	printGameMessage: (message: string) => void;
+	/** @deprecated */
+	runClientScript(params: any[]): void;
+	/** @deprecated */
 	setCounter: (name: string, value: number) => void;
-	setVariable: (
-		variableName: string,
-		value: string | number | boolean | string[] | number[],
-	) => void;
-	togglePrayer: (
-		prayer: net.runelite.api.Prayer,
-		bypassMouseClicks: boolean,
-	) => void;
+	/** @deprecated */
+	setVariable: (variableName: string, value: string | number | boolean | string[] | number[]) => void;
+	/** @deprecated */
+	togglePrayer: (prayer: net.runelite.api.Prayer, bypassMouseClicks: boolean) => void;
+	/** @deprecated */
 	tradePlayer: (names: string[]) => void;
 	/** Use if you're using a World point provided by the Bot Makers World Point true tile debug */
+	/** @deprecated */
 	walkToTrueWorldPoint: (x: number, y: number) => void;
 	/** Use if you're walking to a world point thats already provided by the RL API such as localPlayer.getWorldLocation */
+	/** @deprecated */
 	walkToWorldPoint: (x: number, y: number) => void;
+	/** @deprecated */
 	webWalkCancel: () => void;
+	/** @deprecated */
 	webWalkStart: (point: net.runelite.api.coords.WorldPoint) => void;
+	/** @deprecated */
 	withdrawAllFromBankWithId: (id: number) => void;
+	/** @deprecated */
 	withdrawAllFromBankWithName: (name: string) => void;
+	/** @deprecated */
 	withdrawFromBankWithId: (id: number) => void;
+	/** @deprecated */
 	withdrawFromBankWithName: (name: string) => void;
 }

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

@@ -0,0 +1,117 @@
+/// <reference path="../runelite/index.d.ts" />
+
+declare const bot: SoxBotApi;
+
+interface SoxBotApi {
+	events: net.runelite.client.eventbus.EventBus;
+	bank: {
+		close: () => void;
+		depositAllWithId: (id: number) => void;
+		depositAllWithName: (name: string) => void;
+		depositWithId: (id: number) => void;
+		depositWithName: (name: string) => void;
+		isOpen: () => boolean;
+		withdrawAllWithId: (id: number) => void;
+		withdrawAllWithName: (name: string) => void;
+		withdrawWithId: (id: number) => void;
+		withdrawWithName: (name: string) => void;
+	};
+	bmCache: {
+		getBoolean: (key: string) => boolean;
+		getInt: (key: string) => number;
+		getString: (key: string) => string;
+		saveBoolean: (key: string, value: boolean) => void;
+		saveInt: (key: string, value: number) => void;
+		saveString: (key: string, value: string) => void;
+	};
+	breakHandler: {
+		setBreakHandlerStatus(status: boolean): void;
+	};
+	counters: {
+		getCounter: (name: string) => number;
+		setCounter: (name: string, value: number) => void;
+	};
+	graphicsObjects: {
+		getWithIds: (ids: number[]) => net.runelite.api.GraphicsObject[];
+	};
+	inventory: {
+		interactWithIds: (itemIds: number[], options: string[]) => void;
+		interactWithNames: (itemNames: string[], options: string[]) => void;
+		itemOnItemWithIds: (itemId1: number, itemId2: number) => void;
+		itemOnNpcWithIds: (itemId: number, npc: net.runelite.api.NPC) => void;
+		itemOnObjectWithIds: (itemId: number, tileObject: net.runelite.api.TileObject) => void;
+		itemOnPlayerWithIds: (itemId: number, player: net.runelite.api.Player) => void;
+		itemOnPlayerWithNames: (itemNames: string[], playerNames: string[]) => void;
+	};
+	npcs: {
+		getAnimationID: (npc: net.runelite.api.NPC) => number;
+		getAttackSpeed: (npcId: number) => number;
+		getHeadIcon: (npc: net.runelite.api.NPC) => net.runelite.api.HeadIcon;
+		getWithIds: (ids: number[]) => net.runelite.api.NPC[];
+		getWithNames: (names: string[]) => net.runelite.api.NPC[];
+		interact: (npcName: string, action: string) => void;
+		interactSupplied: (target: net.runelite.api.NPC, action: string) => void;
+	};
+	objects: {
+		getTileObjectComposition: (objectId: number) => net.runelite.api.ObjectComposition;
+		getTileObjectsWithIds: (ids: number[]) => net.runelite.api.TileObject[];
+		getTileObjectsWithNames: (names: string[]) => net.runelite.api.TileObject[];
+		interactObject: (objectName: string, action: string) => void;
+		interactObjects: (objectNames: string[], actions: string[]) => void;
+		interactSuppliedObject: (target: net.runelite.api.TileObject, action: string) => void;
+	};
+	players: {
+		attackPlayer: (names: string[]) => void;
+		followPlayer: (names: string[]) => void;
+		isNearPlayer: (radius: number, names: string[]) => boolean;
+		tradePlayer: (names: string[]) => void;
+	};
+	prayer: {
+		togglePrayer: (prayer: net.runelite.api.Prayer, bypassMouseClicks: boolean) => void;
+	};
+	projectiles: {
+		getProjectilesWithIds: (ids: number[]) => net.runelite.api.Projectile[];
+	};
+	tileItems: {
+		getItemsOfValue: (value: number) => TileItemInfo[];
+		getItemsWithIds: (ids: number[]) => TileItemInfo[];
+		getItemsWithNames: (names: string[]) => TileItemInfo[];
+		lootItem: (tileItemInfo: TileItemInfo) => void;
+		lootItemsOfValue: (value: number, maxDistance: number) => void;
+		lootItemsWithIds: (lootIds: number[], maxDistance: number) => void;
+		lootItemsWithNames: (lootNames: string[], maxDistance: number) => void;
+	};
+	variables: {
+		getBooleanVariable: (variableName: string) => boolean;
+		getIntArrayVariable: (variableName: string) => number[];
+		getIntVariable: (variableName: string) => number;
+		getStringArrayVariable: (variableName: string) => string[];
+		getStringVariable: (variableName: string) => string;
+		setVariable: (variableName: string, value: any) => void;
+	};
+	walking: {
+		isWebWalking: () => boolean;
+		/** Use if you're using a World point provided by the Bot Makers World Point true tile debug */
+		walkToTrueWorldPoint: (x: number, y: number) => void;
+		/** Use if you're walking to a world point thats already provided by the RL API such as localPlayer.getWorldLocation */
+		walkToWorldPoint: (x: number, y: number) => void;
+		webWalkCancel: () => void;
+		webWalkStart: (worldPoint: net.runelite.api.coords.WorldPoint) => void;
+	};
+	widgets: {
+		interactSpecifiedWidget: (packedWidgetId: number, identifier: number, opcode: number, param0: number) => void;
+		interactSpecifiedWidget: (
+			packedWidgetId: number,
+			identifier: number,
+			opcode: number,
+			param0: number,
+			param1: number,
+		) => void;
+		interactWidgetText: (text: string) => void;
+	};
+	clearGameChat: () => void;
+	localPlayerIdle: () => boolean;
+	localPlayerMoving: () => boolean;
+	printGameMessage: (message: string) => void;
+	runClientScript: (ints: number[]) => void;
+}

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

@@ -1,2 +1,8 @@
 /// <reference path="./api/api.d.ts" />
-/// <reference path="./api/client.d.ts" />
+/// <reference path="./api/bot.d.ts" />
+/// <reference path="./api/client.d.ts" />
+
+declare const configManager: {
+	getConfiguration: (groupName: string, key: string) => string | null;
+	setConfiguration: (groupName: string, key: string, value: string) => void;
+};

package/package.json

@@ -1,23 +1,25 @@
 {
 	"name": "@deafwave/osrs-botmaker-types",
-	"version": "0.2.12",
+	"version": "0.3.0",
 	"author": {
 		"name": "Chandler Ferry",
 		"url": "https://github.com/ChandlerFerry"
 	},
 	"description": "Typescript Types for Sox's Botmaker",
-	"license": "UNLICENSED",
+	"license": "Apache-2.0",
 	"type": "module",
 	"contributors": [],
 	"publishConfig": {
-		"access": "public"
+		"access": "public",
+		"registry": "https://registry.npmjs.org"
 	},
 	"exports": {
-		"types": "./dist/src/index.d.ts"
+		"types": "./dist/src/index.d.ts",
+		"default": "./dist/src/exports/index.js"
 	},
+	"main": "./dist/src/exports/index.js",
 	"types": "./dist/src/index.d.ts",
 	"scripts": {
-		"runelite": "tsx scripts/runelite-to-ts/create-runelite-types.ts",
 		"lint": "eslint . --quiet",
 		"build": "tsc && cpy src/index.d.ts dist && cpy src/types dist",
 		"prepublish": "tsc && cpy src/index.d.ts dist && cpy src/types dist"
@@ -35,14 +37,13 @@
 		"@types/fs-extra": "^11.0.4",
 		"@typescript-eslint/eslint-plugin": "^7.1.1",
 		"@typescript-eslint/parser": "^7.1.1",
-		"chalk": "^4.1.0",
+		"cpy-cli": "^5.0.0",
 		"eslint": "^8.57.0",
 		"eslint-config-prettier": "^9.1.0",
 		"eslint-import-resolver-typescript": "^3.6.1",
 		"eslint-plugin-import": "^2.29.1",
 		"eslint-plugin-jest": "^27.9.0",
 		"eslint-plugin-unicorn": "^51.0.1",
-		"fs-extra": "^11.2.0",
 		"jsonc-eslint-parser": "^2.4.0",
 		"prettier": "^3.2.5",
 		"prettier-eslint": "^16.3.0",

package/dist/src/types/java/Collection.d.ts

@@ -1,24 +0,0 @@
-// Collection.d.ts
-interface Collection<T> {
-	size(): number;
-	isEmpty(): boolean;
-	contains(o: T): boolean;
-	iterator(): Iterator<T>;
-	toArray(): T[];
-	add(e: T): boolean;
-	remove(o: T): boolean;
-	containsAll(c: Collection<T>): boolean;
-	addAll(c: Collection<T>): boolean;
-	removeAll(c: Collection<T>): boolean;
-	retainAll(c: Collection<T>): boolean;
-	clear(): void;
-	equals(o: object): boolean;
-	hashCode(): number;
-	forEach(callback: (value: T) => void): void;
-}
-
-interface Iterator<T> {
-	hasNext(): boolean;
-	next(): T;
-	remove(): void;
-}

package/dist/src/types/java/Dimension.d.ts

@@ -1 +0,0 @@
-type Dimension = any;

package/dist/src/types/java/Graphics2D.d.ts

@@ -1,65 +0,0 @@
-// Graphics2D.d.ts
-interface Graphics2D {
-	// Methods for drawing shapes
-	drawLine(x1: number, y1: number, x2: number, y2: number): void;
-	drawRect(x: number, y: number, width: number, height: number): void;
-	fillRect(x: number, y: number, width: number, height: number): void;
-	drawOval(x: number, y: number, width: number, height: number): void;
-	fillOval(x: number, y: number, width: number, height: number): void;
-	drawPolygon(xPoints: number[], yPoints: number[], nPoints: number): void;
-	fillPolygon(xPoints: number[], yPoints: number[], nPoints: number): void;
-
-	// Methods for manipulating graphics settings
-	setColor(color: Color): void; // Assuming a Color interface is defined
-	setStroke(stroke: Stroke): void; // Assuming a Stroke interface is defined
-	setTransform(transform: AffineTransform): void; // Assuming an AffineTransform interface is defined
-	setRenderingHint(key: RenderingHints['key'], value: Object): void; // Assuming appropriate types for RenderingHints and Key
-
-	// Image drawing methods
-	drawImage(
-		img: Image,
-		x: number,
-		y: number,
-		observer: ImageObserver,
-	): boolean; // Assuming Image and ImageObserver interfaces/types are defined
-
-	// Text methods
-	drawString(str: string, x: number, y: number): void;
-
-	// More methods can be added as per requirement
-}
-
-// Supporting interfaces/types
-interface Color {
-	// Color properties and methods
-}
-
-interface Stroke {
-	// Stroke properties and methods
-}
-
-interface AffineTransform {
-	// AffineTransform properties and methods
-}
-
-interface RenderingHints {
-	// RenderingHints properties and methods
-	key: any;
-}
-
-interface Image {
-	// Method to get the width of the image. Returns -1 if the width is not yet known.
-	getWidth(): number;
-
-	// Method to get the height of the image. Returns -1 if the height is not yet known.
-	getHeight(): number;
-
-	// Methods to draw the image might be more complex to represent in TypeScript,
-	// as they would depend on the rendering context (like a canvas context in web applications).
-	// For example:
-	drawImage(context: CanvasRenderingContext2D, x: number, y: number): void;
-}
-
-interface ImageObserver {
-	// ImageObserver properties and methods
-}