@deafwave/osrs-botmaker-types 0.2.12

package/README.md

@@ -0,0 +1,10 @@
+# osrs-botmaker-api
+
+Created by [Chandler 'Deafwave' Ferry](https://github.com/ChandlerFerry) to ease the programming strain of making [Botmaker](https://theplug.runelite.plus) scripts.
+
+## Donate
+- https://ko-fi.com/deafwave
+- ETH/ERC-20: `0x6dEb51c4f253781d9354af86C3c0205eFf75Bf52`
+- BNB/BEP-20: `0x40D84bA476FDEc7485F33eB3b82286366d0022aa`
+- TRX/TRC-20: `TN6t6ZZSz1JQwXtFoo7sbmQAYXiw8JNeCt`
+- BTC: `bc1qetcfw0pj4t3harm8glx8p0jkyeayhcu60emzzc`

package/dist/src/index.d.ts

@@ -0,0 +1 @@
+/// <reference path="./types/index.d.ts" />

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

@@ -0,0 +1,4 @@
+/// <reference path="./java/index.d.ts" />
+/// <reference path="./runelite/index.d.ts" />
+/// <reference path="./sox/index.d.ts" />
+/// <reference path="./rhino/index.d.ts" />

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

@@ -0,0 +1,34 @@
+// BufferedImage.d.ts
+interface BufferedImage {
+	// Basic properties
+	width: number;
+	height: number;
+	imageType: number; // You may use specific enum/constants for different image types
+
+	// Methods to get and set pixel data
+	getRGB(x: number, y: number): number;
+	setRGB(x: number, y: number, rgb: number): void;
+	getRGB(
+		startX: number,
+		startY: number,
+		w: number,
+		h: number,
+		rgbArray: number[],
+		offset: number,
+		scansize: number,
+	): void;
+	setRGB(
+		startX: number,
+		startY: number,
+		w: number,
+		h: number,
+		rgbArray: number[],
+		offset: number,
+		scansize: number,
+	): void;
+
+	// Methods to manipulate graphics
+	createGraphics(): Graphics2D; // Assuming a Graphics2D interface is defined
+
+	// Additional methods can be added as per requirement
+}

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

@@ -0,0 +1,24 @@
+// 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/Comparable.d.ts

@@ -0,0 +1,3 @@
+interface Comparable<T> {
+	compareTo(other: T): number;
+}

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

@@ -0,0 +1,4 @@
+interface Consumer<T> {
+	accept(item: T): void;
+	andThen(after: Consumer<T>): Consumer<T>;
+}

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

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

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

@@ -0,0 +1,4 @@
+type Enum = {
+	getId(): number;
+	toString(): string;
+};

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

@@ -0,0 +1,17 @@
+interface EnumSet<T> {
+	add(e: T): boolean;
+	addAll(collection: EnumSet<T>): boolean;
+	clear(): void;
+	clone(): EnumSet<T>;
+	contains(e: T): boolean;
+	containsAll(collection: EnumSet<T>): boolean;
+	isEmpty(): boolean;
+	remove(e: T): boolean;
+	removeAll(collection: EnumSet<T>): boolean;
+	retainAll(collection: EnumSet<T>): boolean;
+	size(): number;
+	toArray(): T[];
+
+	noneOf(e: T): EnumSet<T>;
+	allOf(e: T): EnumSet<T>;
+}

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

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

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

@@ -0,0 +1,65 @@
+// 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
+}

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

@@ -0,0 +1,7 @@
+interface Injector {
+	getInstance<T>(javaClass: Clazz<T> | null): T;
+}
+
+interface Clazz<T> extends Function {
+	new (...args: any[]): T;
+}

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

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

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

@@ -0,0 +1,40 @@
+interface List<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;
+	get(index: number): T;
+	set(index: number, element: T): T;
+	add(index: number, element: T): void;
+	remove(index: number): T;
+	indexOf(o: T): number;
+	lastIndexOf(o: T): number;
+	// listIterator(): ListIterator<T>;
+	subList(fromIndex: number, toIndex: number): List<T>;
+}
+
+interface Iterator<T> {
+	hasNext(): boolean;
+	next(): T;
+	remove(): void;
+}
+
+// interface ListIterator<T> extends Iterator<T> {
+// 	hasNext(): boolean;
+// 	next(): T;
+// 	hasPrevious(): boolean;
+// 	previous(): T;
+// 	nextIndex(): number;
+// 	previousIndex(): number;
+// 	remove(): void;
+// 	set(e: T): void;
+// 	add(e: T): void;
+// }

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

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

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

@@ -0,0 +1,12 @@
+/// <reference path="Rectangle.d.ts" />
+
+interface Polygon extends Shape {
+	protected Rectangle: bounds;
+
+	constructor(): void;
+	constructor(xpoints: number[], ypoints: number[], npoints: number): void;
+
+	npoints: number;
+	xpoints: number[];
+	ypoints: number[];
+}

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

@@ -0,0 +1,32 @@
+interface Predicate<T> {
+	/**
+	 * Evaluates this predicate on the given argument.
+	 *
+	 * @param t the input argument
+	 * @returns true if the input argument matches the predicate, otherwise false
+	 */
+	test(t: T): boolean;
+
+	/**
+	 * Combines this predicate with another one using logical and.
+	 *
+	 * @param other a predicate that will be logically-ANDed with this predicate
+	 * @returns a composed predicate that represents the short-circuiting logical AND of this predicate and the other
+	 */
+	and(other: Predicate<T>): Predicate<T>;
+
+	/**
+	 * Combines this predicate with another one using logical or.
+	 *
+	 * @param other a predicate that will be logically-ORed with this predicate
+	 * @returns a composed predicate that represents the short-circuiting logical OR of this predicate and the other
+	 */
+	or(other: Predicate<T>): Predicate<T>;
+
+	/**
+	 * Returns a predicate that represents the logical negation of this predicate.
+	 *
+	 * @returns a predicate that represents the logical negation of this predicate
+	 */
+	negate(): Predicate<T>;
+}

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

@@ -0,0 +1,13 @@
+interface Rectangle {
+	// Properties
+	x: number;
+	y: number;
+	width: number;
+	height: number;
+
+	// Methods
+	contains(x: number, y: number): boolean;
+	contains(x: number, y: number, width: number, height: number): boolean;
+	intersects(rect: Rectangle): boolean;
+	union(rect: Rectangle): Rectangle;
+}

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

@@ -0,0 +1,37 @@
+/// <reference path="./Rectangle.d.ts" />
+interface Shape {
+	// Methods to get the bounding box of the shape
+	getBounds(): Rectangle; // Assuming a Rectangle interface is defined
+	getBounds2D(): Rectangle2D; // Assuming a Rectangle2D interface is defined
+
+	// Methods to test if a point or rectangle lies inside the boundary of the shape
+	contains(x: number, y: number): boolean;
+	contains(x: number, y: number, width: number, height: number): boolean;
+	contains(point: Point2D): boolean; // Assuming a Point2D interface is defined
+	contains(rect: Rectangle2D): boolean; // Assuming a Rectangle2D interface is defined
+
+	// Methods to test if the interior of the shape intersects or is adjacent to the interior of a specified rectangular area
+	intersects(x: number, y: number, width: number, height: number): boolean;
+	intersects(rect: Rectangle2D): boolean; // Assuming a Rectangle2D interface is defined
+
+	// Method to get an object that iterates along the shape's boundary
+	getPathIterator(at: AffineTransform): PathIterator; // Assuming AffineTransform and PathIterator interfaces are defined
+
+	// More methods can be added as per requirement
+}
+
+interface Rectangle2D {
+	// Rectangle2D properties and methods
+}
+
+interface Point2D {
+	// Point2D properties and methods
+}
+
+interface AffineTransform {
+	// AffineTransform properties and methods
+}
+
+interface PathIterator {
+	// PathIterator properties and methods
+}

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

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

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

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

package/dist/src/types/java/awt/BasicStroke.d.ts

@@ -0,0 +1,18 @@
+declare namespace java.awt {
+	class BasicStroke {
+		constructor(
+			width: number,
+			cap?: number,
+			join?: number,
+			miterlimit?: number,
+			dash?: number[],
+			dash_phase?: number,
+		);
+		getLineWidth(): number;
+		getEndCap(): number;
+		getLineJoin(): number;
+		getMiterLimit(): number;
+		getDashArray(): number[];
+		getDashPhase(): number;
+	}
+}

package/dist/src/types/java/awt/Canvas.d.ts

@@ -0,0 +1,6 @@
+/// <reference path="./event/KeyEvent.d.ts" />
+declare namespace java.awt {
+	export class Canvas {
+		dispatchEvent(event: java.awt.event.KeyEvent): void;
+	}
+}

package/dist/src/types/java/awt/Color.d.ts

@@ -0,0 +1,28 @@
+declare namespace java.awt {
+	export class Color {
+		constructor(hexString: string);
+		constructor(r: number, g: number, b: number);
+		constructor(r: number, g: number, b: number, a: number);
+
+		static BLACK: Color;
+		static BLUE: Color;
+		static CYAN: Color;
+		static DARK_GRAY: Color;
+		static GRAY: Color;
+		static GREEN: Color;
+		static LIGHT_GRAY: Color;
+		static MAGENTA: Color;
+		static ORANGE: Color;
+		static PINK: Color;
+		static RED: Color;
+		static WHITE: Color;
+		static YELLOW: Color;
+
+		getRed(): number;
+		getGreen(): number;
+		getBlue(): number;
+		getAlpha(): number;
+
+		static decode(hexString: string): Color;
+	}
+}

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

@@ -0,0 +1,39 @@
+declare namespace java.awt {
+	export class 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
+	}
+}

package/dist/src/types/java/awt/Point.d.ts

@@ -0,0 +1,8 @@
+declare namespace java.awt {
+	export class Point {
+		constructor(x: number, y: number);
+		getX(): number;
+		getY(): number;
+		setLocation(x: number, y: number): void;
+	}
+}

package/dist/src/types/java/awt/event/KeyEvent.d.ts

@@ -0,0 +1,15 @@
+declare namespace java.awt.event {
+	export class KeyEvent {
+		constructor(
+			source: any, // java.awt.Component
+			id: number,
+			when: number,
+			modifiers: number,
+			keyCode: number,
+			keyChar: string | number, // char type?
+		);
+
+		static VK_UNDEFINED: number;
+		static VK_ENTER: number;
+	}
+}

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

@@ -0,0 +1,31 @@
+/// <reference path="./BufferedImage.d.ts" />
+/// <reference path="./Comparable.d.ts" />
+/// <reference path="./Consumer.d.ts" />
+/// <reference path="./Dimension.d.ts" />
+/// <reference path="./Enum.d.ts" />
+/// <reference path="./EnumSet.d.ts" />
+/// <reference path="./Graphics.d.ts" />
+/// <reference path="./awt/Graphics2D.d.ts" />
+/// <reference path="./awt/BasicStroke.d.ts" />
+/// <reference path="./JavaMouseEvent.d.ts" />
+/// <reference path="./List.d.ts" />
+/// <reference path="./MouseWheelEvent.d.ts" />
+/// <reference path="./Injector.d.ts" />
+/// <reference path="./Polygon.d.ts" />
+/// <reference path="./Predicate.d.ts" />
+/// <reference path="./Rectangle.d.ts" />
+/// <reference path="./Shape.d.ts" />
+/// <reference path="./Thread.d.ts" />
+/// <reference path="./Throwable.d.ts" />
+/// <reference path="./lang/Runnable.d.ts" />
+/// <reference path="./lang/String.d.ts" />
+/// <reference path="./lang/Thread.d.ts" />
+/// <reference path="./awt/Canvas.d.ts" />
+/// <reference path="./awt/Color.d.ts" />
+/// <reference path="./awt/Point.d.ts" />
+/// <reference path="./awt/event/KeyEvent.d.ts" />
+/// <reference path="./util/LinkedList.d.ts" />
+/// <reference path="./util/HashSet.d.ts" />
+/// <reference path="./util/Set.d.ts" />
+/// <reference path="./util/Collection.d.ts" />
+/// <reference path="./io/FileWriter.d.ts" />

package/dist/src/types/java/io/FileWriter.d.ts

@@ -0,0 +1,11 @@
+declare namespace java.io {
+	export class FileWriter {
+		/**
+		 * append: true for append, false for overwrite
+		 */
+		constructor(filePath: string, append: boolean);
+
+		write(data: string): void;
+		close(): void;
+	}
+}

package/dist/src/types/java/lang/Runnable.d.ts

@@ -0,0 +1,5 @@
+declare namespace java.lang {
+	export class Runnable {
+		constructor(runnable: { run: () => void });
+	}
+}

package/dist/src/types/java/lang/String.d.ts

@@ -0,0 +1,5 @@
+declare namespace java.lang {
+	export class String {
+		toCharArray(): string[];
+	}
+}

package/dist/src/types/java/lang/Thread.d.ts

@@ -0,0 +1,8 @@
+/// <reference path="./Runnable.d.ts" />
+declare namespace java.lang {
+	export class Thread {
+		constructor(runnable: Runnable);
+		start(): void;
+		static sleep(millis: number): void;
+	}
+}

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

@@ -0,0 +1,25 @@
+// declare namespace java.util {
+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/util/HashSet.d.ts

@@ -0,0 +1,19 @@
+declare namespace java.util {
+	export class HashSet<T> {
+		private items: T[];
+
+		constructor();
+
+		add(item: T): void;
+
+		remove(item: T): void;
+
+		contains(item: T): boolean;
+
+		size(): number;
+
+		toArray(): T[];
+
+		clear(): void;
+	}
+}

package/dist/src/types/java/util/LinkedList.d.ts

@@ -0,0 +1,16 @@
+declare namespace java.util {
+	export class LinkedList<T> {
+		constructor();
+		add(element: T): boolean;
+		add(index: number, element: T): void;
+		clear(): void;
+		contains(o: T): boolean;
+		get(index: number): T;
+		indexOf(o: T): number;
+		isEmpty(): boolean;
+		remove(index: number): T;
+		size(): number;
+		toArray(): T[];
+		poll(): T;
+	}
+}

package/dist/src/types/java/util/Set.d.ts

@@ -0,0 +1,11 @@
+declare namespace java.util {
+	export interface Set<T> extends java.util.Collection<E> {
+		add(element: T): boolean;
+		clear(): void;
+		contains(element: T): boolean;
+		isEmpty(): boolean;
+		remove(element: T): boolean;
+		size(): number;
+		toArray(): T[];
+	}
+}

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

@@ -0,0 +1,5 @@
+type JavaAdapterType = <T>(
+	Function,
+	implementation: Partial<Record<keyof T, (typeof T)[keyof T]>>,
+) => T & U;
+declare const JavaAdapter: JavaAdapterType;

package/dist/src/types/runelite/com/jagex/oldscape/pub/OAuthApi.d.ts

@@ -0,0 +1,34 @@
+/// <reference path="../../../../../../../src/types/java/index.d.ts" />
+/// <reference path="../../../../../../../src/types/runelite/index.d.ts" />
+/*
+ * Copyright (c) 2022, Adam <Adam@sigterm.info>
+ * All rights reserved.
+ *
+ * Redistribution and use in source and binary forms, with or without
+ * modification, are permitted provided that the following conditions are met:
+ *
+ * 1. Redistributions of source code must retain the above copyright notice, this
+ *    list of conditions and the following disclaimer.
+ * 2. Redistributions in binary form must reproduce the above copyright notice,
+ *    this list of conditions and the following disclaimer in the documentation
+ *    and/or other materials provided with the distribution.
+ *
+ * THIS SOFTWARE IS PROVIDED BY THE COPYRIGHT HOLDERS AND CONTRIBUTORS "AS IS" AND
+ * ANY EXPRESS OR IMPLIED WARRANTIES, INCLUDING, BUT NOT LIMITED TO, THE IMPLIED
+ * WARRANTIES OF MERCHANTABILITY AND FITNESS FOR A PARTICULAR PURPOSE ARE
+ * DISCLAIMED. IN NO EVENT SHALL THE COPYRIGHT OWNER OR CONTRIBUTORS BE LIABLE FOR
+ * ANY DIRECT, INDIRECT, INCIDENTAL, SPECIAL, EXEMPLARY, OR CONSEQUENTIAL DAMAGES
+ * (INCLUDING, BUT NOT LIMITED TO, PROCUREMENT OF SUBSTITUTE GOODS OR SERVICES;
+ * LOSS OF USE, DATA, OR PROFITS; OR BUSINESS INTERRUPTION) HOWEVER CAUSED AND
+ * ON ANY THEORY OF LIABILITY, WHETHER IN CONTRACT, STRICT LIABILITY, OR TORT
+ * (INCLUDING NEGLIGENCE OR OTHERWISE) ARISING IN ANY WAY OUT OF THE USE OF THIS
+ * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
+ */
+declare namespace com.jagex.oldscape.pub {
+	export class OAuthApi {
+		/**
+		 * Gets a unique per-RuneScape-Account identifier or {@code -1} if the client has not logged in yet
+		 */
+		getAccountHash(): number;
+	}
+}