@deafwave/osrs-botmaker-types 0.2.13 → 0.3.1

package/dist/src/types/runelite/net/runelite/client/ui/overlay/infobox/Counter.d.ts

@@ -25,9 +25,8 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.infobox {
-export class Counter extends InfoBox
-{
-	getText(): string;
-	getTextColor(): Color;
+	export class Counter extends InfoBox {
+		getText(): string;
+		getTextColor(): java.awt.Color;
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/infobox/InfoBox.d.ts

@@ -25,14 +25,13 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.infobox {
-export class InfoBox
-{
-	getText(): string;
-	getTextColor(): Color;
-	render(): boolean;
-	cull(): boolean;
-	getName(): string;
+	export class InfoBox {
+		getText(): string;
+		getTextColor(): java.awt.Color;
+		render(): boolean;
+		cull(): boolean;
+		getName(): string;
 		// Use a combination of plugin name and infobox implementation name to try and make each infobox as unique
 		// as possible by default
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/infobox/InfoBoxOverlay.d.ts

@@ -26,18 +26,17 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.infobox {
-export class InfoBoxOverlay extends OverlayPanel
-{
-	getName(): string;
-	render(graphics: Graphics2D): Dimension;
+	export class InfoBoxOverlay extends OverlayPanel {
+		getName(): string;
+		render(graphics: Graphics2D): java.awt.Dimension;
 		// Set preferred size to the size of DEFAULT_WRAP_COUNT infoboxes, including the padding - which is applied
 		// to the last infobox prior to wrapping too.
 		// Handle tooltips
-			// Create intersection rectangle
-	getMenuEntries(): Array<OverlayMenuEntry>;
+		// Create intersection rectangle
+		getMenuEntries(): Array<OverlayMenuEntry>;
 		// we dynamically build the menu options based on which infobox is hovered
-	onMenuOptionClicked(menuOptionClicked: net.runelite.api.events.MenuOptionClicked): void;
-	onDrag(source: Overlay): boolean;
-	flip(): ComponentOrientation;
+		onMenuOptionClicked(menuOptionClicked: net.runelite.api.events.MenuOptionClicked): void;
+		onDrag(source: Overlay): boolean;
+		flip(): ComponentOrientation;
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/infobox/LoopTimer.d.ts

@@ -25,11 +25,10 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.infobox {
-export class LoopTimer extends InfoBox
-{
-	getText(): string;
-	getTextColor(): Color;
+	export class LoopTimer extends InfoBox {
+		getText(): string;
+		getTextColor(): java.awt.Color;
 		// check if timer has 10% of time left
-	private getProgress(): Duration;
+		private getProgress(): Duration;
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/infobox/Timer.d.ts

@@ -25,22 +25,21 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.infobox {
-export class Timer extends InfoBox
-{
-	getText(): string;
-	getTextColor(): Color;
+	export class Timer extends InfoBox {
+		getText(): string;
+		getTextColor(): java.awt.Color;
 		//check if timer has 10% of time left
-	render(): boolean;
-	cull(): boolean;
-	/**
-	 * Update the timer duration *relative to the start time*
-	 * @param duration
-	 */
-	setDuration(duration: Duration): void;
-	/**
-	 * Update the timer duration relative to now
-	 * @param duration
-	 */
-	updateDuration(duration: Duration): void;
+		render(): boolean;
+		cull(): boolean;
+		/**
+		 * Update the timer duration *relative to the start time*
+		 * @param duration
+		 */
+		setDuration(duration: Duration): void;
+		/**
+		 * Update the timer duration relative to now
+		 * @param duration
+		 */
+		updateDuration(duration: Duration): void;
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/outline/ModelOutlineRenderer.d.ts

@@ -25,172 +25,205 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.outline {
-export class ModelOutlineRenderer
-{
-/** TBD-1 */
-// export class PixelDistanceDelta
-/** TBD-1 */
-// export class PixelDistanceGroupIndex
-	// Vertex positions projected on the screen.
-	// Window boundaries for the ingame world
-	// Boundaries for the outline
-	// Bitset with pixel positions that would be rendered to within the cropped area by the model.
-	// Memory used for queueing the pixels for the outline of the model.
-	// Pixels are grouped by x and y distance to the closest pixel drawn on the model.
-	// A block buffer is used so memory can be reused after a group has been processed
-	// without using the JVM garbage collector.
-	// An array of pixel group indices ordered by distance for each outline width and feather.
-	// These are calculated once upon first usage and then stored here to skip reevaluation.
-	// An array of pixel distance deltas for each outline width and direction (right/up/left/down).
-	// These are calculated once upon first usage and then stored here to skip reevaluation.
-	/**
-	 * Calculate the next power of two of a value.
-	 *
-	 * @param value The value to find the next power of two of.
-	 * @return Returns the next power of two.
-	 */
-	private static nextPowerOfTwo(value: number): number;
-	/**
-	 * Determine if a triangle goes counter clockwise
-	 *
-	 * @return Returns true if the triangle goes counter clockwise and should be culled, otherwise false
-	 */
-	private static cullFace(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;
-	/**
-	 * Get an array of pixel outline group indices ordered by distance for a specific outline width.
-	 *
-	 * @param outlineWidth The outline width.
-	 * @param feather The feather of the outline.
-	 * @return Returns the list of pixel distances.
-	 */
-	private getPriorityList(outlineWidth: number, feather: number): PixelDistanceGroupIndex[];
-	private ensureDistanceDeltasCreated(outlineWidth: number): void;
-			// Turn 90 deg ccw
-	/**
-	 * Enqueues a pixel for outlining.
-	 *
-	 * @param distanceGroupIndex The group index to enqueue the pixel into.
-	 * @param x The x position of the pixel.
-	 * @param y The y position of the pixel.
-	 */
-	private enqueueOutlinePixel(distanceGroupIndex: number, x: number, y: number): void;
-	/**
-	 * Checks that the visited bitset is big enough to hold a certain amount of pixels and sets them to 0.
-	 *
-	 * @param pixelAmount The amount of pixels needed.
-	 */
-	private resetVisited(pixelAmount: number): void;
-	/**
-	 * Ensures that the outline buffer arrays are large enough to fit the current outline.
-	 */
-	private initializeOutlineBuffers(): void;
-	/**
-	 * Frees all blocks currently in use by the outline block buffer.
-	 */
-	private freeAllBlockMemory(): void;
-	/**
-	 * Simulates a horizontal line rasterization and marks pixels visited.
-	 *
-	 * @param pixelY The y position of the line
-	 * @param x1 The starting x position
-	 * @param x2 The ending x position
-	 */
-	private simulateHorizontalLineRasterizationForOutline(pixelY: number, x1: number, x2: number): void;
-	/**
-	 * Simulates rasterization of a triangle and marks pixels visited.
-	 *
-	 * @param x1 The x position of the first vertex in the triangle
-	 * @param y1 The y position of the first vertex in the triangle
-	 * @param x2 The x position of the second vertex in the triangle
-	 * @param y2 The y position of the second vertex in the triangle
-	 * @param x3 The x position of the third vertex in the triangle
-	 * @param y3 The y position of the third vertex in the triangle
-	 */
-	private simulateTriangleRasterizationForOutline(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): void;
+	export class ModelOutlineRenderer {
+		/** TBD-1 */
+		// export class PixelDistanceDelta
+		/** TBD-1 */
+		// export class PixelDistanceGroupIndex
+		// Vertex positions projected on the screen.
+		// Window boundaries for the ingame world
+		// Boundaries for the outline
+		// Bitset with pixel positions that would be rendered to within the cropped area by the model.
+		// Memory used for queueing the pixels for the outline of the model.
+		// Pixels are grouped by x and y distance to the closest pixel drawn on the model.
+		// A block buffer is used so memory can be reused after a group has been processed
+		// without using the JVM garbage collector.
+		// An array of pixel group indices ordered by distance for each outline width and feather.
+		// These are calculated once upon first usage and then stored here to skip reevaluation.
+		// An array of pixel distance deltas for each outline width and direction (right/up/left/down).
+		// These are calculated once upon first usage and then stored here to skip reevaluation.
+		/**
+		 * Calculate the next power of two of a value.
+		 *
+		 * @param value The value to find the next power of two of.
+		 * @return Returns the next power of two.
+		 */
+		private static nextPowerOfTwo(value: number): number;
+		/**
+		 * Determine if a triangle goes counter clockwise
+		 *
+		 * @return Returns true if the triangle goes counter clockwise and should be culled, otherwise false
+		 */
+		private static cullFace(x1: number, y1: number, x2: number, y2: number, x3: number, y3: number): boolean;
+		/**
+		 * Get an array of pixel outline group indices ordered by distance for a specific outline width.
+		 *
+		 * @param outlineWidth The outline width.
+		 * @param feather The feather of the outline.
+		 * @return Returns the list of pixel distances.
+		 */
+		private getPriorityList(outlineWidth: number, feather: number): PixelDistanceGroupIndex[];
+		private ensureDistanceDeltasCreated(outlineWidth: number): void;
+		// Turn 90 deg ccw
+		/**
+		 * Enqueues a pixel for outlining.
+		 *
+		 * @param distanceGroupIndex The group index to enqueue the pixel into.
+		 * @param x The x position of the pixel.
+		 * @param y The y position of the pixel.
+		 */
+		private enqueueOutlinePixel(distanceGroupIndex: number, x: number, y: number): void;
+		/**
+		 * Checks that the visited bitset is big enough to hold a certain amount of pixels and sets them to 0.
+		 *
+		 * @param pixelAmount The amount of pixels needed.
+		 */
+		private resetVisited(pixelAmount: number): void;
+		/**
+		 * Ensures that the outline buffer arrays are large enough to fit the current outline.
+		 */
+		private initializeOutlineBuffers(): void;
+		/**
+		 * Frees all blocks currently in use by the outline block buffer.
+		 */
+		private freeAllBlockMemory(): void;
+		/**
+		 * Simulates a horizontal line rasterization and marks pixels visited.
+		 *
+		 * @param pixelY The y position of the line
+		 * @param x1 The starting x position
+		 * @param x2 The ending x position
+		 */
+		private simulateHorizontalLineRasterizationForOutline(pixelY: number, x1: number, x2: number): void;
+		/**
+		 * Simulates rasterization of a triangle and marks pixels visited.
+		 *
+		 * @param x1 The x position of the first vertex in the triangle
+		 * @param y1 The y position of the first vertex in the triangle
+		 * @param x2 The x position of the second vertex in the triangle
+		 * @param y2 The y position of the second vertex in the triangle
+		 * @param x3 The x position of the third vertex in the triangle
+		 * @param y3 The y position of the third vertex in the triangle
+		 */
+		private simulateTriangleRasterizationForOutline(
+			x1: number,
+			y1: number,
+			x2: number,
+			y2: number,
+			x3: number,
+			y3: number,
+		): void;
 		// Swap vertices so y1 <= y2 <= y3 using bubble sort
-			// All points are outside clip boundaries
-	/**
-	 * Translates the vertices 3D points to the screen canvas 2D points.
-	 *
-	 * @param localX The local x position of the vertices.
-	 * @param localY The local y position of the vertices.
-	 * @param localZ The local z position of the vertices.
-	 * @param vertexOrientation The orientation of the vertices.
-	 * @return Returns true if any of them are inside the clip area, otherwise false.
-	 */
-	private projectVertices(model: Model, localX: number, localY: number, localZ: number, vertexOrientation: number): boolean;
-				// Vertex is too close or behind camera and isn't rendered
-	/**
-	 * Simulates rendering of the model and marks every pixel visited.
-	 */
-	private simulateModelRasterizationForOutline(model: Model): void;
-				// 254 and 255 counts as fully transparent
-	/**
-	 * Draws the outline of a pixel according to the distance deltas of an outline.
-	 *
-	 * @param imageData The image data to draw to.
-	 * @param imageWidth The width of the image to draw to.
-	 * @param x The x position of the pixel.
-	 * @param y The y position of the pixel.
-	 * @param distanceDeltas The distance deltas of the outline width.
-	 * @param color The color to draw the outline in.
-	 */
-	private rasterDistanceDeltas(imageData: number[], imageWidth: number, x: number, y: number, distanceDeltas: PixelDistanceDelta[], color: number): void;
-	/**
-	 * Enqueues pixels that are adjacent above or below the model
-	 * or draws them directly to the clients image buffer.
-	 *
-	 * @param directWrite If true the pixels are drawn to the image buffer, otherwise they are enqueued for drawing.
-	 * @param color The color to draw if directWrite == true
-	 * @param outlineWidth The outline width to draw if directWrite == true
-	 */
-	private processInitialOutlinePixels(directWrite: boolean, color: Color, outlineWidth: number): void;
+		// All points are outside clip boundaries
+		/**
+		 * Translates the vertices 3D points to the screen canvas 2D points.
+		 *
+		 * @param localX The local x position of the vertices.
+		 * @param localY The local y position of the vertices.
+		 * @param localZ The local z position of the vertices.
+		 * @param vertexOrientation The orientation of the vertices.
+		 * @return Returns true if any of them are inside the clip area, otherwise false.
+		 */
+		private projectVertices(
+			model: Model,
+			localX: number,
+			localY: number,
+			localZ: number,
+			vertexOrientation: number,
+		): boolean;
+		// Vertex is too close or behind camera and isn't rendered
+		/**
+		 * Simulates rendering of the model and marks every pixel visited.
+		 */
+		private simulateModelRasterizationForOutline(model: Model): void;
+		// 254 and 255 counts as fully transparent
+		/**
+		 * Draws the outline of a pixel according to the distance deltas of an outline.
+		 *
+		 * @param imageData The image data to draw to.
+		 * @param imageWidth The width of the image to draw to.
+		 * @param x The x position of the pixel.
+		 * @param y The y position of the pixel.
+		 * @param distanceDeltas The distance deltas of the outline width.
+		 * @param color The color to draw the outline in.
+		 */
+		private rasterDistanceDeltas(
+			imageData: number[],
+			imageWidth: number,
+			x: number,
+			y: number,
+			distanceDeltas: PixelDistanceDelta[],
+			color: number,
+		): void;
+		/**
+		 * Enqueues pixels that are adjacent above or below the model
+		 * or draws them directly to the clients image buffer.
+		 *
+		 * @param directWrite If true the pixels are drawn to the image buffer, otherwise they are enqueued for drawing.
+		 * @param color The color to draw if directWrite == true
+		 * @param outlineWidth The outline width to draw if directWrite == true
+		 */
+		private processInitialOutlinePixels(directWrite: boolean, color: java.awt.Color, outlineWidth: number): void;
 		// Up and down
-						// Special case handling outlineWidth == 1 gives a
-						// small but noticeable performance improvement.
+		// Special case handling outlineWidth == 1 gives a
+		// small but noticeable performance improvement.
 		// Left and right
-				// Test adjacent pixels in the same 32-bit segment
-						// Special case handling outlineWidth == 1 gives a
-						// small but noticeable performance improvement.
-				// Test adjacent pixels in different 32-bit segments
-	/**
-	 * Process the outline queue and draw an outline of the pixels
-	 * in the queue to the client image buffer.
-	 *
-	 * @param outlineWidth The width of the outline.
-	 * @param color The color of the outline.
-	 */
-	private processOutlinePixelQueue(outlineWidth: number, color: Color, feather: number): void;
-	/**
-	 * Draws an outline around a model to an image
-	 *
-	 * @param localX The local x position of the model
-	 * @param localY The local y position of the model
-	 * @param localZ The local z position of the model
-	 * @param orientation The orientation of the model
-	 * @param outlineWidth The width of the outline
-	 * @param color The color of the outline
-	 */
-	private drawModelOutline(model: Model, localX: number, localY: number, localZ: number, orientation: number, outlineWidth: number, color: Color, feather: number): void;
-			// No vertex of the model is visible on the screen, so we can
-			// assume there are no parts of the model to outline.
+		// Test adjacent pixels in the same 32-bit segment
+		// Special case handling outlineWidth == 1 gives a
+		// small but noticeable performance improvement.
+		// Test adjacent pixels in different 32-bit segments
+		/**
+		 * Process the outline queue and draw an outline of the pixels
+		 * in the queue to the client image buffer.
+		 *
+		 * @param outlineWidth The width of the outline.
+		 * @param color The color of the outline.
+		 */
+		private processOutlinePixelQueue(outlineWidth: number, color: java.awt.Color, feather: number): void;
+		/**
+		 * Draws an outline around a model to an image
+		 *
+		 * @param localX The local x position of the model
+		 * @param localY The local y position of the model
+		 * @param localZ The local z position of the model
+		 * @param orientation The orientation of the model
+		 * @param outlineWidth The width of the outline
+		 * @param color The color of the outline
+		 */
+		private drawModelOutline(
+			model: Model,
+			localX: number,
+			localY: number,
+			localZ: number,
+			orientation: number,
+			outlineWidth: number,
+			color: java.awt.Color,
+			feather: number,
+		): void;
+		// No vertex of the model is visible on the screen, so we can
+		// assume there are no parts of the model to outline.
 		// We can improve performance and reduce memory needed when drawing
 		// only a small outline around the model by skipping the pixel queueing
 		// and instead raster pixels directly. This only looks right for opaque
 		// outlines since some pixels of the outline can get drawn more than once.
 		// Performance becomes worse than queueing when using larger outline widths,
 		// usually around 10 px outline width according to some basic testing.
-	drawOutline(npc: NPC, outlineWidth: number, color: Color, feather: number): void;
-			// NPCs z position are calculated based on the tile height of the northeastern tile
-	drawOutline(player: Player, outlineWidth: number, color: Color, feather: number): void;
-	private drawOutline(gameObject: GameObject, outlineWidth: number, color: Color, feather: number): void;
-	private drawOutline(groundObject: GroundObject, outlineWidth: number, color: Color, feather: number): void;
-	private drawOutline(itemLayer: ItemLayer, outlineWidth: number, color: Color, feather: number): void;
-	private drawOutline(decorativeObject: DecorativeObject, outlineWidth: number, color: Color, feather: number): void;
-				// Offset is not used for the second model
-	private drawOutline(wallObject: WallObject, outlineWidth: number, color: Color, feather: number): void;
-	drawOutline(tileObject: TileObject, outlineWidth: number, color: Color, feather: number): void;
-	drawOutline(graphicsObject: GraphicsObject, outlineWidth: number, color: Color, feather: number): void;
-	drawOutline(runeLiteObject: RuneLiteObject, outlineWidth: number, color: Color, feather: number): void;
+		drawOutline(npc: NPC, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		// NPCs z position are calculated based on the tile height of the northeastern tile
+		drawOutline(player: Player, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		private drawOutline(gameObject: GameObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		private drawOutline(groundObject: GroundObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		private drawOutline(itemLayer: ItemLayer, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		private drawOutline(
+			decorativeObject: DecorativeObject,
+			outlineWidth: number,
+			color: java.awt.Color,
+			feather: number,
+		): void;
+		// Offset is not used for the second model
+		private drawOutline(wallObject: WallObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		drawOutline(tileObject: TileObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		drawOutline(graphicsObject: GraphicsObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+		drawOutline(runeLiteObject: RuneLiteObject, outlineWidth: number, color: java.awt.Color, feather: number): void;
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/tooltip/TooltipOverlay.d.ts

@@ -25,12 +25,11 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.tooltip {
-export class TooltipOverlay extends Overlay
-{
+	export class TooltipOverlay extends Overlay {
 		// additionally allow tooltips above the full screen world map and welcome screen
-	render(graphics: Graphics2D): Dimension;
-			// Tooltips must always be cleared each frame
-	private renderTooltips(graphics: Graphics2D, tooltips: Array<Tooltip>): Dimension;
-			// Create incremental tooltip newBounds
+		render(graphics: Graphics2D): java.awt.Dimension;
+		// Tooltips must always be cleared each frame
+		private renderTooltips(graphics: Graphics2D, tooltips: Array<Tooltip>): java.awt.Dimension;
+		// Create incremental tooltip newBounds
+	}
 }
-}

package/dist/src/types/runelite/net/runelite/client/ui/overlay/worldmap/WorldMapOverlay.d.ts

@@ -25,31 +25,30 @@
  * SOFTWARE, EVEN IF ADVISED OF THE POSSIBILITY OF SUCH DAMAGE.
  */
 declare namespace net.runelite.client.ui.overlay.worldmap {
-export class WorldMapOverlay extends Overlay
-{
-	render(graphics: Graphics2D): Dimension;
-					// Get a smaller rect for edge-snapped icons so they display correctly at the edge
-					// Make the unsnap rect slightly smaller so a smaller snapped image doesn't cause a freak out
-	/**
-	 * Get the screen coordinates for a WorldPoint on the world map
-	 *
-	 * @param worldPoint WorldPoint to get screen coordinates of
-	 * @return Point of screen coordinates of the center of the world point
-	 */
-	mapWorldPointToGraphicsPoint(worldPoint: net.runelite.api.coords.WorldPoint): Point;
-			//Offset in tiles from anchor sides
-			//Center on tile.
-	/**
-	 * Gets a clip area which excludes the area of widgets which overlay the world map.
-	 *
-	 * @param baseRectangle The base area to clip from
-	 * @return              An {@link Area} representing <code>baseRectangle</code>, with the area
-	 *                      of visible widgets overlaying the world map clipped from it.
-	 */
-	private getWorldMapClipArea(baseRectangle: Rectangle): Shape;
+	export class WorldMapOverlay extends Overlay {
+		render(graphics: Graphics2D): java.awt.Dimension;
+		// Get a smaller rect for edge-snapped icons so they display correctly at the edge
+		// Make the unsnap rect slightly smaller so a smaller snapped image doesn't cause a freak out
+		/**
+		 * Get the screen coordinates for a WorldPoint on the world map
+		 *
+		 * @param worldPoint WorldPoint to get screen coordinates of
+		 * @return Point of screen coordinates of the center of the world point
+		 */
+		mapWorldPointToGraphicsPoint(worldPoint: net.runelite.api.coords.WorldPoint): Point;
+		//Offset in tiles from anchor sides
+		//Center on tile.
+		/**
+		 * Gets a clip area which excludes the area of widgets which overlay the world map.
+		 *
+		 * @param baseRectangle The base area to clip from
+		 * @return              An {@link Area} representing <code>baseRectangle</code>, with the area
+		 *                      of visible widgets overlaying the world map clipped from it.
+		 */
+		private getWorldMapClipArea(baseRectangle: Rectangle): Shape;
 		// The sun g2d implementation is much more efficient at applying clips which are subclasses of rectangle2d,
 		// so use that as the clip shape if possible
-	private drawTooltip(graphics: Graphics2D, worldPoint: WorldMapPoint): void;
-	private clipToRectangle(drawPoint: Point, mapDisplayRectangle: Rectangle): Point;
+		private drawTooltip(graphics: Graphics2D, worldPoint: WorldMapPoint): void;
+		private clipToRectangle(drawPoint: Point, mapDisplayRectangle: Rectangle): Point;
+	}
 }
-}