@deafwave/osrs-botmaker-types 0.3.1 → 0.3.8

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

@@ -0,0 +1,8 @@
+/*declare const Java: {
+	
+	to<T>(array: unknown, typeName: string): T;
+
+	
+	type<T = unknown>(className: string): { new (...args: unknown[]): T };
+};
+*/

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

@@ -0,0 +1,6 @@
+declare namespace java {
+	export class JavaImporter {
+		public modules: any[];
+		constructor(...modules: any[]);
+	}
+}

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

@@ -0,0 +1,16 @@
+declare namespace java.awt {
+	export class BorderLayout {
+		static NORTH: string;
+		static SOUTH: string;
+		static EAST: string;
+		static WEST: string;
+		static CENTER: string;
+		constructor(hgap?: number, vgap?: number);
+		getHgap(): number;
+		setHgap(hgap: number): void;
+		getVgap(): number;
+		setVgap(vgap: number): void;
+	}
+}
+
+type BorderLayout = java.awt.BorderLayout;

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

@@ -43,3 +43,5 @@ declare namespace java.awt {
 		static decode(hexString: string): Color;
 	}
 }
+
+type Color = java.awt.Color;

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

@@ -0,0 +1,5 @@
+declare namespace java.awt {
+	export abstract class Component {
+		paint(g: Graphics2D): void;
+	}
+}

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

@@ -0,0 +1,12 @@
+declare namespace java.awt {
+	export class Container {
+		add(comp: java.awt.Component, constraints?: any): java.awt.Component;
+		remove(comp: java.awt.Component): void;
+		removeAll(): void;
+		setLayout(layout: java.awt.LayoutManager): void;
+		validate(): void;
+		repaint(): void;
+	}
+}
+
+type Container = java.awt.Container;

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

@@ -0,0 +1,16 @@
+declare namespace java.awt {
+	export class FlowLayout {
+		static LEFT: number;
+		static CENTER: number;
+		static RIGHT: number;
+		static LEADING: number;
+		static TRAILING: number;
+		constructor(alignment?: number, hgap?: number, vgap?: number);
+		getHgap(): number;
+		setHgap(hgap: number): void;
+		getVgap(): number;
+		setVgap(vgap: number): void;
+	}
+}
+
+type FlowLayout = java.awt.FlowLayout;

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

@@ -0,0 +1,24 @@
+declare namespace java.awt {
+	class Font {
+		constructor(name: string, style: number, size: number);
+
+		static PLAIN: number;
+		static BOLD: number;
+		static ITALIC: number;
+
+		getName(): string;
+		getStyle(): number;
+		getSize(): number;
+		getFamily(): string;
+		isBold(): boolean;
+		isItalic(): boolean;
+		isPlain(): boolean;
+
+		deriveFont(style: number): Font;
+		deriveFont(size: number): Font;
+		deriveFont(style: number, size: number): Font;
+
+		toString(): string;
+		equals(obj: any): boolean;
+	}
+}

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

@@ -0,0 +1,5 @@
+declare namespace java.awt {
+	export class GradientPaint {
+		constructor(x1: number, y1: number, color1: Color, x2: number, y2: number, color2: Color);
+	}
+}

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

@@ -8,7 +8,9 @@ declare namespace java.awt {
 		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;
-
+		draw(shape: Shape): void; // Assuming a Shape interface is defined
+		fill(shape: Shape | Polygon): void;
+		getColor(): java.awt.Color; // Assuming a Color interface is defined
 		// Methods for manipulating graphics settings
 		setColor(color: java.awt.Color): void; // Assuming a Color interface is defined
 		setStroke(stroke: Stroke): void; // Assuming a Stroke interface is defined

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

@@ -0,0 +1,56 @@
+/// <reference path="./Insets.d.ts" />
+declare namespace java.awt {
+	export class GridBagConstraints {
+		static RELATIVE: number;
+		static REMAINDER: number;
+		static NONE: number;
+		static BOTH: number;
+		static HORIZONTAL: number;
+		static VERTICAL: number;
+		static CENTER: number;
+		static NORTH: number;
+		static NORTHEAST: number;
+		static EAST: number;
+		static SOUTHEAST: number;
+		static SOUTH: number;
+		static SOUTHWEST: number;
+		static WEST: number;
+		static NORTHWEST: number;
+		static PAGE_START: number;
+		static PAGE_END: number;
+		static LINE_START: number;
+		static LINE_END: number;
+		static FIRST_LINE_START: number;
+		static FIRST_LINE_END: number;
+		static LAST_LINE_START: number;
+		static LAST_LINE_END: number;
+
+		gridx: number;
+		gridy: number;
+		gridwidth: number;
+		gridheight: number;
+		weightx: number;
+		weighty: number;
+		anchor: number;
+		fill: number;
+		insets: java.awt.Insets;
+		ipadx: number;
+		ipady: number;
+
+		constructor(
+			gridx?: number,
+			gridy?: number,
+			gridwidth?: number,
+			gridheight?: number,
+			weightx?: number,
+			weighty?: number,
+			anchor?: number,
+			fill?: number,
+			insets?: java.awt.Insets,
+			ipadx?: number,
+			ipady?: number,
+		);
+	}
+}
+
+type GridBagConstraints = java.awt.GridBagConstraints;

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

@@ -0,0 +1,13 @@
+declare namespace java.awt {
+	export class GridBagLayout {
+		constructor();
+		addLayoutComponent(name: string, comp: any): void;
+		removeLayoutComponent(comp: any): void;
+		layoutContainer(parent: any): void;
+		getLayoutAlignmentX(target: any): number;
+		getLayoutAlignmentY(target: any): number;
+		invalidateLayout(target: any): void;
+	}
+}
+
+type GridBagLayout = java.awt.GridBagLayout;

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

@@ -0,0 +1,28 @@
+declare namespace java.awt {
+	export class Insets {
+		/** The inset from the top edge. */
+		top: number;
+		/** The inset from the left edge. */
+		left: number;
+		/** The inset from the bottom edge. */
+		bottom: number;
+		/** The inset from the right edge. */
+		right: number;
+		/**
+		 * Creates and initializes a new Insets object with the specified top, left,
+		 * bottom, and right insets.
+		 * @param top    the inset from the top edge
+		 * @param left   the inset from the left edge
+		 * @param bottom the inset from the bottom edge
+		 * @param right  the inset from the right edge
+		 */
+		constructor(top: number, left: number, bottom: number, right: number);
+		/**
+		 * Returns a string representation of this Insets object,
+		 * e.g. "java.awt.Insets[top=2,left=3,bottom=4,right=5]"
+		 */
+		toString(): string;
+	}
+}
+
+type Insets = java.awt.Insets;

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

@@ -0,0 +1,14 @@
+declare namespace java.awt {
+	export class Polygon {
+		constructor();
+		constructor(xpoints: number[], ypoints: number[], npoints: number);
+		addPoint(x: number, y: number): void;
+		contains(x: number, y: number): boolean;
+		contains(point: java.awt.Point): boolean;
+		getBounds(): java.awt.Rectangle;
+		getBoundingBox(): java.awt.Rectangle;
+		npoints: number;
+		xpoints: number[];
+		ypoints: number[];
+	}
+}

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

@@ -0,0 +1,18 @@
+declare namespace java.awt {
+	export class Rectangle {
+		constructor();
+		constructor(x: number, y: number, width: number, height: number);
+		contains(x: number, y: number): boolean;
+		contains(point: java.awt.Point): boolean;
+		intersects(r: java.awt.Rectangle): boolean;
+		getBounds(): java.awt.Rectangle;
+		getLocation(): java.awt.Point;
+		getSize(): java.awt.Dimension;
+		setLocation(x: number, y: number): void;
+		setSize(width: number, height: number): void;
+		x: number;
+		y: number;
+		width: number;
+		height: number;
+	}
+}

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

@@ -0,0 +1,15 @@
+declare namespace java.awt {
+	export class Toolkit {
+		/**
+		 * Returns the default Toolkit instance.
+		 */
+		static getDefaultToolkit(): Toolkit;
+
+		/**
+		 * Returns the system clipboard.
+		 */
+		getSystemClipboard(): java.awt.datatransfer.Clipboard;
+
+		sync(): void;
+	}
+}

package/dist/src/types/java/awt/datatransfer/Clipboard.d.ts

@@ -0,0 +1,40 @@
+declare namespace java.awt.datatransfer {
+	/**
+	 * The Clipboard class is a container for transferable data.
+	 */
+	export class Clipboard {
+		/**
+		 * Constructs a clipboard object.
+		 * @param name The name of this clipboard object.
+		 */
+		constructor(name: string);
+
+		/**
+		 * Sets the current contents of the clipboard to the specified transferable object.
+		 * @param contents The transferable object representing the clipboard content.
+		 * @param owner The object that owns the clipboard content.
+		 */
+		setContents(contents: Transferable, owner: ClipboardOwner | null): void;
+
+		/**
+		 * Returns the current transferable object on the clipboard.
+		 * @param requestor The object requesting the contents (often null).
+		 */
+		getContents(requestor: any): Transferable | null;
+
+		/**
+		 * Returns an array of DataFlavor objects indicating the flavors the data can be provided in.
+		 */
+		getAvailableDataFlavors(): DataFlavor[];
+
+		/**
+		 * Returns whether or not the specified DataFlavor is available on this clipboard.
+		 */
+		isDataFlavorAvailable(flavor: DataFlavor): boolean;
+
+		/**
+		 * Returns an object representing the current contents of this clipboard in the specified DataFlavor.
+		 */
+		getData(flavor: DataFlavor): any;
+	}
+}

package/dist/src/types/java/awt/datatransfer/ClipboardOwner.d.ts

@@ -0,0 +1,14 @@
+declare namespace java.awt.datatransfer {
+	/**
+	 * Defines the interface for classes that will be notified when they
+	 * no longer own the clipboard contents.
+	 */
+	export interface ClipboardOwner {
+		/**
+		 * Notifies the owner that it no longer owns the clipboard contents. (According to stackoverflow)
+		 * @param clipboard The clipboard that is no longer owned.
+		 * @param contents The contents which this owner had placed on the clipboard.
+		 */
+		lostOwnership(clipboard: Clipboard, contents: Transferable): void;
+	}
+}

package/dist/src/types/java/awt/datatransfer/DataFlavor.d.ts

@@ -0,0 +1,33 @@
+declare namespace java.awt.datatransfer {
+	/**
+	 * Represents the type of data to be transferred via clipboard or drag and drop.
+	 */
+	export class DataFlavor {
+		/**
+		 * Creates a DataFlavor from a MIME type and a human-readable name.
+		 */
+		constructor(mimeType: string, humanPresentableName?: string);
+
+		/**
+		 * Returns the MIME type string for this DataFlavor.
+		 */
+		getMimeType(): string;
+
+		/**
+		 * Returns the human presentable name for the data format.
+		 */
+		getHumanPresentableName(): string;
+
+		/**
+		 * Sets the human presentable name for the data format.
+		 */
+		setHumanPresentableName(name: string): void;
+
+		/**
+		 * Compares the MIME type of this DataFlavor to another's.
+		 */
+		isMimeTypeEqual(mimeType: string): boolean;
+
+		// Additional methods from the DataFlavor class can be added here if needed.
+	}
+}

package/dist/src/types/java/awt/datatransfer/StringSelection.d.ts

@@ -0,0 +1,34 @@
+declare namespace java.awt.datatransfer {
+	/**
+	 * simple class that implements Transferable and ClipboardOwner,
+	 * providing the capability of transferring a string.
+	 */
+	export class StringSelection implements Transferable, ClipboardOwner {
+		/**
+		 * Creates a StringSelection object for the specified string.
+		 */
+		constructor(data: string);
+
+		/**
+		 * Returns an array of DataFlavor objects indicating the flavors
+		 * in which the data can be provided.
+		 */
+		getTransferDataFlavors(): DataFlavor[];
+
+		/**
+		 * Returns whether or not the specified data flavor is supported.
+		 */
+		isDataFlavorSupported(flavor: DataFlavor): boolean;
+
+		/**
+		 * Returns the transfer data in the requested flavor.
+		 */
+		getTransferData(flavor: DataFlavor): any;
+
+		/**
+		 * ClipboardOwner callback: invoked when the clipboard contents change
+		 * and this object is no longer the clipboard owner.
+		 */
+		lostOwnership(clipboard: Clipboard, contents: Transferable): void;
+	}
+}

package/dist/src/types/java/awt/datatransfer/Transferable.d.ts

@@ -0,0 +1,24 @@
+declare namespace java.awt.datatransfer {
+	/**
+	 * Defines the interface for classes that can provide data
+	 * to be transferred via clipboard or drag-and-drop operations.
+	 */
+	export interface Transferable {
+		/**
+		 * Returns an array of DataFlavor objects indicating the flavors
+		 * in which the data can be provided.
+		 */
+		getTransferDataFlavors(): DataFlavor[];
+
+		/**
+		 * Returns whether or not the specified data flavor is supported.
+		 */
+		isDataFlavorSupported(flavor: DataFlavor): boolean;
+
+		/**
+		 * Returns the transfer data in the requested flavor.
+		 * @param flavor The requested flavor for the data.
+		 */
+		getTransferData(flavor: DataFlavor): any;
+	}
+}

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

@@ -0,0 +1,6 @@
+declare namespace java.awt.event {
+	export class ActionListener {
+		constructor(callback: (event: any) => void);
+		actionPerformed(event: any): void;
+	}
+}

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

@@ -0,0 +1,6 @@
+declare namespace javax.swing.event {
+	export class ChangeListener {
+		constructor(callback: (event: any) => void);
+		stateChanged(event: any): void;
+	}
+}

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

@@ -0,0 +1,28 @@
+declare namespace javax.swing.event {
+	/**
+	 * Listens for changes to a Document (e.g., a JTextField's document).
+	 */
+	export interface DocumentListener {
+		/** Fired when text is inserted into the document */
+		insertUpdate?(e: any): void;
+		/** Fired when text is removed from the document */
+		removeUpdate?(e: any): void;
+		/** Fired when an attribute or style changes */
+		changedUpdate?(e: any): void;
+	}
+
+	/**
+	 * Adapter class to let you implement only the methods you need.
+	 * Usage: new DocumentAdapter({ insertUpdate: e => { ... } });
+	 * THis will eventually be used for our searchBar.
+	 */
+	export class DocumentAdapter implements DocumentListener {
+		constructor(options: Partial<DocumentListener>);
+		insertUpdate(e: any): void;
+		removeUpdate(e: any): void;
+		changedUpdate(e: any): void;
+	}
+}
+
+type DocumentListener = javax.swing.event.DocumentListener;
+type DocumentAdapter = javax.swing.event.DocumentAdapter;

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

@@ -0,0 +1,15 @@
+declare namespace java.awt.event {
+	export class FocusListener {
+		constructor(options: { focusGained?: (event: any) => void; focusLost?: (event: any) => void });
+		focusGained(event: any): void;
+		focusLost(event: any): void;
+	}
+
+	export class FocusAdapter implements FocusListener {
+		private focusGainedCallback?: (event: any) => void;
+		private focusLostCallback?: (event: any) => void;
+		constructor(options: { focusGained?: (event: any) => void; focusLost?: (event: any) => void });
+		focusGained(event: any): void;
+		focusLost(event: any): void;
+	}
+}

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

@@ -0,0 +1,11 @@
+declare namespace java.awt.event {
+	export class ItemListener {
+		constructor(callback: (event: any) => void);
+		itemStateChanged(event: any): void;
+	}
+	export class ItemAdapter implements ItemListener {
+		private _itemStateChangedCallback?: (event: any) => void;
+		constructor(callback?: (event: any) => void);
+		itemStateChanged(event: any): void;
+	}
+}

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

@@ -0,0 +1,9 @@
+declare namespace java.awt.event {
+	export abstract class KeyAdapter implements java.awt.event.KeyListener {
+		keyPressed?(event: java.awt.event.KeyEvent): void;
+		keyReleased?(event: java.awt.event.KeyEvent): void;
+		keyTyped?(event: java.awt.event.KeyEvent): void;
+	}
+}
+
+type KeyAdapter = java.awt.event.KeyAdapter;

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

@@ -1,15 +1,79 @@
 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?
-		);
+		constructor(source: any, id: number, when: number, modifiers: number, keyCode: number, keyChar: string | number);
 
+		// Event types
+		static KEY_PRESSED: number;
+		static KEY_RELEASED: number;
+		static KEY_TYPED: number;
+
+		// Common key codes
+		static CHAR_UNDEFINED: number;
 		static VK_UNDEFINED: number;
 		static VK_ENTER: number;
+		static VK_BACK_SPACE: number;
+		static VK_TAB: number;
+		static VK_CANCEL: number;
+		static VK_CLEAR: number;
+		static VK_SHIFT: number;
+		static VK_CONTROL: number;
+		static VK_ALT: number;
+		static VK_ESCAPE: number;
+		static VK_SPACE: number;
+		static VK_LEFT: number;
+		static VK_UP: number;
+		static VK_RIGHT: number;
+		static VK_DOWN: number;
+		static VK_DELETE: number;
+
+		// Alphabetic keys
+		static VK_A: number;
+		static VK_B: number;
+		static VK_C: number;
+		static VK_D: number;
+		static VK_E: number;
+		static VK_F: number;
+		static VK_G: number;
+		static VK_H: number;
+		static VK_I: number;
+		static VK_J: number;
+		static VK_K: number;
+		static VK_L: number;
+		static VK_M: number;
+		static VK_N: number;
+		static VK_O: number;
+		static VK_P: number;
+		static VK_Q: number;
+		static VK_R: number;
+		static VK_S: number;
+		static VK_T: number;
+		static VK_U: number;
+		static VK_V: number;
+		static VK_W: number;
+		static VK_X: number;
+		static VK_Y: number;
+		static VK_Z: number;
+
+		// Numeric keys
+		static VK_0: number;
+		static VK_1: number;
+		static VK_2: number;
+		static VK_3: number;
+		static VK_4: number;
+		static VK_5: number;
+		static VK_6: number;
+		static VK_7: number;
+		static VK_8: number;
+		static VK_9: number;
+
+		getKeyCode(): number; // Returns the key code of the event
+		getKeyChar(): string; // Returns the character associated with the event
+		isShiftDown(): boolean; // Checks if Shift is held
+		isControlDown(): boolean; // Checks if Ctrl is held
+		isAltDown(): boolean; // Checks if Alt is held
+		isMetaDown(): boolean; // Checks if Meta (Cmd/Windows) is held
+		consume(): void; // Prevents default behavior of the key event
 	}
 }
+
+type KeyEvent = java.awt.event.KeyEvent;

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

@@ -0,0 +1,7 @@
+declare namespace java.awt.event {
+	export interface KeyListener {
+		keyPressed?(event: java.awt.event.KeyEvent): void;
+		keyReleased?(event: java.awt.event.KeyEvent): void;
+		keyTyped?(event: java.awt.event.KeyEvent): void;
+	}
+}

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

@@ -0,0 +1,11 @@
+declare namespace java.awt.event {
+	export abstract class MouseAdapter {
+		mouseClicked?(e: MouseEvent): void;
+		mousePressed?(e: MouseEvent): void;
+		mouseReleased?(e: MouseEvent): void;
+		mouseEntered?(e: MouseEvent): void;
+		mouseExited?(e: MouseEvent): void;
+	}
+}
+
+type MouseAdapter = java.awt.event.MouseAdapter;

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

@@ -0,0 +1,11 @@
+declare namespace java.awt.event {
+	export class MouseListener {
+		constructor(options: {
+			mouseClicked?: (event: any) => void;
+			mousePressed?: (event: any) => void;
+			mouseReleased?: (event: any) => void;
+			mouseEntered?: (event: any) => void;
+			mouseExited?: (event: any) => void;
+		});
+	}
+}

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

@@ -0,0 +1,25 @@
+declare namespace java.awt.event {
+	export interface WindowListener {
+		windowOpened?(e: any): void;
+		windowClosing?(e: any): void;
+		windowClosed?(e: any): void;
+		windowIconified?(e: any): void;
+		windowDeiconified?(e: any): void;
+		windowActivated?(e: any): void;
+		windowDeactivated?(e: any): void;
+	}
+
+	export class WindowAdapter implements WindowListener {
+		constructor(options: Partial<WindowListener>);
+		windowOpened?(e: any): void;
+		windowClosing?(e: any): void;
+		windowClosed?(e: any): void;
+		windowIconified?(e: any): void;
+		windowDeiconified?(e: any): void;
+		windowActivated?(e: any): void;
+		windowDeactivated?(e: any): void;
+	}
+}
+
+type WindowListener = java.awt.event.WindowListener;
+type WindowAdapter = java.awt.event.WindowAdapter;