@deafwave/osrs-botmaker-types 0.2.12 → 0.3.0

package/README.md

@@ -1,4 +1,4 @@
-# osrs-botmaker-api
+# osrs-botmaker-types
 
 Created by [Chandler 'Deafwave' Ferry](https://github.com/ChandlerFerry) to ease the programming strain of making [Botmaker](https://theplug.runelite.plus) scripts.
 
@@ -8,3 +8,5 @@ Created by [Chandler 'Deafwave' Ferry](https://github.com/ChandlerFerry) to ease
 - BNB/BEP-20: `0x40D84bA476FDEc7485F33eB3b82286366d0022aa`
 - TRX/TRC-20: `TN6t6ZZSz1JQwXtFoo7sbmQAYXiw8JNeCt`
 - BTC: `bc1qetcfw0pj4t3harm8glx8p0jkyeayhcu60emzzc`
+
+

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

@@ -0,0 +1 @@
+export declare const placeholder: {};

package/dist/src/api/index.js

@@ -0,0 +1 @@
+export const placeholder = {};

package/dist/src/index.d.ts

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

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

@@ -1,13 +1,6 @@
 declare namespace java.awt {
-	class BasicStroke {
-		constructor(
-			width: number,
-			cap?: number,
-			join?: number,
-			miterlimit?: number,
-			dash?: number[],
-			dash_phase?: number,
-		);
+	export class BasicStroke {
+		constructor(width: number, cap?: number, join?: number, miterlimit?: number, dash?: number[], dash_phase?: number);
 		getLineWidth(): number;
 		getEndCap(): number;
 		getLineJoin(): number;

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

@@ -1,8 +1,25 @@
 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);
+		constructor(hexString: string | number);
+		constructor(
+			/** 0.00 - 1.00 */
+			r: number,
+			/** 0.00 - 1.00 */
+			g: number,
+			/** 0.00 - 1.00 */
+			b: number,
+		);
+
+		constructor(
+			/** 0.00 - 1.00 */
+			r: number,
+			/** 0.00 - 1.00 */
+			g: number,
+			/** 0.00 - 1.00 */
+			b: number,
+			/** 0.00 - 1.00 */
+			a: number,
+		);
 
 		static BLACK: Color;
 		static BLUE: Color;

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

@@ -0,0 +1,55 @@
+declare namespace java.awt {
+	export class Dimension {
+		/**
+		 * Constructs a Dimension and initializes it to 0, 0.
+		 */
+		constructor();
+
+		/**
+		 * Constructs a Dimension and initializes it to the specified width and height.
+		 * @param width the specified width
+		 * @param height the specified height
+		 */
+		constructor(width: number, height: number);
+
+		/**
+		 * The width dimension; negative values can be used.
+		 */
+		width: number;
+
+		/**
+		 * The height dimension; negative values can be used.
+		 */
+		height: number;
+
+		/**
+		 * Sets the size of this Dimension object to the specified width and height.
+		 * @param width the new width for the Dimension object
+		 * @param height the new height for the Dimension object
+		 */
+		setSize(width: number, height: number): void;
+
+		/**
+		 * Gets the size of this Dimension object.
+		 * @return the size of this Dimension, a new instance of Dimension with the same width and height
+		 */
+		getSize(): java.awt.Dimension;
+
+		/**
+		 * Checks whether two dimension objects have equal values.
+		 */
+		equals(obj: any): boolean;
+
+		/**
+		 * Returns the hash code for this Dimension.
+		 * @return a hash code for this Dimension
+		 */
+		hashCode(): number;
+
+		/**
+		 * Returns a string representation of the values of this Dimension's height and width fields.
+		 * @return a string representation of this Dimension, including the values of its height and width fields
+		 */
+		toString(): string;
+	}
+}

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

@@ -6,30 +6,17 @@ declare namespace java.awt {
 		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;
+		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
+		setColor(color: java.awt.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
+		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;

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

@@ -1,7 +1,6 @@
 /// <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" />
@@ -15,17 +14,15 @@
 /// <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/index.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/Dimension.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/index.d.ts" />
 /// <reference path="./util/Collection.d.ts" />
 /// <reference path="./io/FileWriter.d.ts" />

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

@@ -0,0 +1,30 @@
+/// <reference path="./Runnable.d.ts" />
+declare namespace java.lang {
+	export class Thread {
+		constructor(runnable: Runnable);
+		start(): void;
+		static sleep(millis: number): void;
+	}
+
+	export class Integer {
+		static MAX_VALUE: number;
+		static BYTES: number;
+		static MIN_VALUE: number;
+		static SIZE: number;
+		static TYPE: string;
+		static parseInt(s: string): number;
+		static toHexString(i: number): string;
+		static toString(i: number): string;
+		static valueOf(i: number): Integer;
+	}
+
+	export interface Iterable<T> {
+		iterator(): Iterator<T>;
+		splitIterator(): SplitIterator<T>;
+		/** This type might be wrong, it may be
+		 *
+		 * forEach(action: Consumer<T>): void;
+		 */
+		forEach(callback: (value: T) => void): void;
+	}
+}

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

@@ -0,0 +1,231 @@
+declare namespace java.util {
+	export 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;
+	}
+	
+	export interface Iterator<T> {
+		hasNext(): boolean;
+		next(): T;
+		remove(): void;
+	}
+
+	export class Collections {
+		static disjoint<T>(c1: Collection<T>, c2: Collection<T>): boolean;
+	
+		static checkedCollection<T>(c: Collection<T>, type: { new(): T }): Collection<T>
+	
+		static checkedList<T>(list: List<T>, type: { new(): T }): List<T>
+	
+		static checkedMap<K, V>(m: Map<K, V>, keyType: { new(): K }, valueType: { new(): V }): Map<K, V>
+	
+		static checkedSet<T>(s: Set<T>, type: { new(): T }): Set<T>
+		static emptyList<T>(): List<T>
+	
+		static emptyMap<K, V>(): Map<K, V>
+		static emptySet<T>(): Set<T>
+	
+		static singletonList<T>(item: T): List<T>
+	
+		static singletonMap<K, V>(key: K, value: V): Map<K, V>
+	
+		static singletonSet<T>(item: T): Set<T>
+
+		static reverse<T>(list: List<T> | ArrayList<T>): void;
+	}
+
+	export interface List<T> implements Collection<T> {
+        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>;
+
+		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;
+    }
+
+	export interface ListIterator<T> extends Iterator<T> {
+        hasPrevious(): boolean;
+        previous(): T;
+        nextIndex(): number;
+        previousIndex(): number;
+        set(e: T): void;
+        add(e: T): void;
+    }
+	
+    export interface Set<T> extends Collection<E> {
+		add(element: T): boolean;
+		clear(): void;
+		contains(element: T): boolean;
+		isEmpty(): boolean;
+		remove(element: T): boolean;
+		size(): number;
+		toArray(): T[];
+	}
+
+    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;
+	}
+
+    export class HashSet<T> implements Collection<T> {
+		private items: T[];
+
+		constructor();
+		constructor(c: Collection<T>);
+
+		add(item: T): void;
+
+		remove(item: T): void;
+
+		contains(item: T): boolean;
+
+		size(): number;
+
+		toArray(): T[];
+
+		clear(): void;
+
+		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;
+	}
+
+	export class ArrayDeque<E> {
+        constructor();
+
+        add(element: E): boolean;
+        addFirst(element: E): void;
+        addLast(element: E): void;
+        clear(): void;
+        clone(): ArrayDeque<E>;
+        contains(element: Object): boolean;
+        isEmpty(): boolean;
+        iterator(): Iterator<E>;
+        offer(element: E): boolean;
+        offerFirst(element: E): boolean;
+        offerLast(element: E): boolean;
+        peek(): E | null;
+        peekFirst(): E | null;
+        peekLast(): E | null;
+        poll(): E | null;
+        pollFirst(): E | null;
+        pollLast(): E | null;
+        remove(): E;
+        removeFirst(): E;
+        removeLast(): E;
+        size(): number;
+    }
+
+	export interface Deque<e> extends Queue<E> {
+		addFirst(e: E): void;
+		addLast(e: E): void;
+		offerFirst(e: E): boolean;
+		offerLast(e: E): boolean;
+		removeFirst(): E;
+		removeLast(): E;
+		pollFirst(): E;
+		pollLast(): E;
+		getFirst(): E;
+		getLast(): E;
+		peekFirst(): E;
+		peekLast(): E;
+		removeFirstOccurrence(o: Object): boolean;
+		removeLastOccurrence(o: Object): boolean;
+		add(e: E): boolean;
+		offer(e: E): boolean;
+		remove(): E;
+		poll(): E;
+		element(): E;
+		peek(): E;
+		push(e: E): void;
+		pop(): E;
+		iterator(): Iterator<E>;
+		descendingIterator(): Iterator<E>;
+	}
+
+	export interface Queue<E> extends Collection<E> {
+		add(e: E): boolean;
+		offer(e: E): boolean;
+		remove(): E;
+		poll(): E;
+		element(): E;
+		peek(): E;
+	}
+
+	export class ArrayList<E> implements List<E> {
+		size(): number;
+		isEmpty(): boolean;
+		contains(o: E): boolean;
+		iterator(): Iterator<E>;
+		toArray(): E[];
+		add(e: E): boolean;
+		remove(o: E): boolean;
+		containsAll(c: Collection<E>): boolean;
+		addAll(c: Collection<E>): boolean;
+		removeAll(c: Collection<E>): boolean;
+		retainAll(c: Collection<E>): boolean;
+		clear(): void;
+		get(index: number): E;
+		set(index: number, element: E): E;
+		add(index: number, element: E): void;
+		remove(index: number): E;
+		indexOf(o: E): number;
+		lastIndexOf(o: E): number;
+		listIterator(): ListIterator<E>;
+		listIterator(index: number): ListIterator<E>;
+		subList(fromIndex: number, toIndex: number): List<E>;
+	}
+}

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

@@ -1183,6 +1183,7 @@
 /// <reference path="./net/runelite/client/account/AccountClient.d.ts" />
 /// <reference path="./net/runelite/client/account/AccountSession.d.ts" />
 /// <reference path="./net/runelite/client/account/SessionManager.d.ts" />
+
 /// <reference path="./net/runelite/api/AABB.d.ts" />
 /// <reference path="./net/runelite/api/Actor.d.ts" />
 /// <reference path="./net/runelite/api/ActorSpotAnim.d.ts" />
@@ -1324,6 +1325,8 @@
 /// <reference path="./net/runelite/api/widgets/JavaScriptCallback.d.ts" />
 /// <reference path="./net/runelite/api/widgets/Widget.d.ts" />
 /// <reference path="./net/runelite/api/widgets/WidgetConfig.d.ts" />
+/// <reference path="./net/runelite/api/widgets/ComponentID.d.ts" />
+/// <reference path="./net/runelite/api/widgets/InterfaceID.d.ts" />
 /// <reference path="./net/runelite/api/widgets/WidgetID.d.ts" />
 /// <reference path="./net/runelite/api/widgets/WidgetInfo.d.ts" />
 /// <reference path="./net/runelite/api/widgets/WidgetItem.d.ts" />
@@ -1445,4 +1448,7 @@
 /// <reference path="./net/runelite/api/annotations/Varp.d.ts" />
 /// <reference path="./net/runelite/api/annotations/VisibleForDevtools.d.ts" />
 /// <reference path="./net/runelite/api/annotations/VisibleForExternalPlugins.d.ts" />
-/// <reference path="./com/jagex/oldscape/pub/OAuthApi.d.ts" />
+
+/// <reference path="./net/runelite/http/api/item/index.d.ts" />
+
+/// <reference path="./com/jagex/oldscape/pub/OAuthApi.d.ts" />