blockbench-types 4.8.0 → 4.9.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockbench-types",
-  "version": "4.8.0",
+  "version": "4.9.0",
   "description": "Blockbench typescript types",
   "main": "",
   "types": "types/blockbench.d.ts",

package/scripts/generate_docs.js

@@ -16,6 +16,7 @@ async function main() {
 		entryPoints: [
 			"./types/blockbench.d.ts",
 			"./types/textures.d.ts",
+			"./types/texture_layers.d.ts",
 			"./types/action.d.ts",
 			"./types/animation.d.ts",
 			"./types/animation_controller.d.ts",
@@ -43,6 +44,7 @@ async function main() {
 			"./types/painter.d.ts",
 			"./types/screencam.d.ts",
 			"./types/validator.d.ts",
+			"./types/shared_actions.d.ts",
 			"./types/display_mode.d.ts",
 			"./types/misc.d.ts",
 			"./types/util.d.ts"

package/types/animation.d.ts

@@ -5,6 +5,7 @@ declare class AnimationItem {
 
 interface AnimationOptions {
     name?: string
+    path?: string
     loop?: 'once' | 'hold' | 'loop'
     override?: boolean
     anim_time_update?: string
@@ -34,7 +35,7 @@ declare class _Animation extends AnimationItem {
     save(): this | undefined;
     select(): this | undefined;
     setLength(length: number): void;
-    createUniqueName(references: Animation[]): any;
+    createUniqueName(references: _Animation[]): any;
     rename(): this;
     togglePlayingState(state: any): any;
     showContextMenu(event: any): this;
@@ -46,7 +47,7 @@ declare class _Animation extends AnimationItem {
      * Adds the animation to the current project and to the interface
      * @param undo If true, the addition of the animation will be registered as an edit
      */
-    add(undo: any): this;
+    add(undo?: any): this;
     remove(undo: any, remove_from_file?: boolean): this;
     getMaxLength(): number;
     setLoop(value: any, undo: any): void;
@@ -86,6 +87,7 @@ declare class _Animation extends AnimationItem {
 declare namespace Animator {
     const open: boolean
     const MolangParser: object
+    const possible_channels: unknown[];
     const motion_trail: THREE.Object3D
     const motion_trail_lock: boolean
     const particle_effects: object
@@ -114,13 +116,14 @@ interface AddChannelOptions {
     max_data_points?: number
 }
 declare class GeneralAnimator {
-    constructor(uuid: string, animation: Animation)
-    keyframes: Keyframe[]
+    constructor(uuid: string, animation: _Animation, name: string)
+    uuid: string
+    keyframes: _Keyframe[]
     select(): this
     addToTimeline(): this
-    addKeyframe(data: KeyframeOptions, uuid: string): Keyframe
-    createKeyframe(): Keyframe
-    getOrMakeKeyframe(): {before: Keyframe, result: Keyframe}
+    addKeyframe(data: KeyframeOptions, uuid?: string): _Keyframe
+    createKeyframe(): _Keyframe
+    getOrMakeKeyframe(): {before: _Keyframe, result: _Keyframe}
     toggleMuted(channel: string): this
     scrollTo(): this
 
@@ -130,9 +133,9 @@ declare class GeneralAnimator {
 declare class BoneAnimator extends GeneralAnimator {
     name: string
     uuid: string
-    rotations: Keyframe[]
-    position: Keyframe[]
-    scale: Keyframe[]
+    rotations: _Keyframe[]
+    position: _Keyframe[]
+    scale: _Keyframe[]
     getGroup(): Group
     fillValues(): void
     pushKeyframe(): void
@@ -146,9 +149,9 @@ declare class BoneAnimator extends GeneralAnimator {
 declare class NullObjectAnimator extends GeneralAnimator {
     name: string
     uuid: string
-    rotations: Keyframe[]
-    position: Keyframe[]
-    scale: Keyframe[]
+    rotations: _Keyframe[]
+    position: _Keyframe[]
+    scale: _Keyframe[]
     getElement(): NullObject
     doRender(): void
     displayPosition(): void
@@ -156,11 +159,12 @@ declare class NullObjectAnimator extends GeneralAnimator {
     displayFrame(): void
 }
 declare class EffectAnimator extends GeneralAnimator {
+    constructor(animation: _Animation)
     name: string
     uuid: string
-    particle: Keyframe[]
-    sound: Keyframe[]
-    timeline: Keyframe[]
+    particle: _Keyframe[]
+    sound: _Keyframe[]
+    timeline: _Keyframe[]
     pushKeyframe(keyframe): this
     displayFrame(in_loop): this
     startPreviousSounds(): void

package/types/animation_controller.d.ts

@@ -63,7 +63,7 @@ declare class AnimationControllerState {
     remove(undo?: boolean): void
     createUniqueName(): void
 
-    addAnimation(animation?: Animation): void
+    addAnimation(animation?: _Animation): void
     addTransition(target_uuid?: string): void
     addParticle(options?: {effect: string}): void
     addSound(options?: {effect: string, file: string}): void

package/types/blockbench.d.ts

@@ -5,6 +5,7 @@
 /// <reference types="wintersky" />
 
 /// <reference types="./textures" />
+/// <reference types="./texture_layers" />
 /// <reference types="./action" />
 /// <reference types="./animation" />
 /// <reference types="./animation_controller" />
@@ -32,10 +33,13 @@
 /// <reference types="./painter" />
 /// <reference types="./screencam" />
 /// <reference types="./validator" />
+/// <reference types="./shared_actions" />
 /// <reference types="./display_mode" />
 /// <reference types="./misc" />
 /// <reference types="./util" />
+/// <reference types="./math_util" />
 /// <reference types="./canvas_frame" />
+/// <reference types="./io" />
 
 
 	
@@ -190,6 +194,12 @@ declare namespace Blockbench {
 	export function showStatusMessage(message: string, time?: number): void
 
 	export function setStatusBarText(text?: string): void
+
+	/**
+	 * Display a tooltip displaying a custom text that appears next to and follows the mouse cursor
+	 * @param text The text to display. Line breaks are supported. Leave empty to hide the tooltip.
+	 */
+	export function setCursorTooltip(text?: string): void
 	/**
 	 * Set the value of a progress bar
 	 * 
@@ -248,7 +258,7 @@ declare namespace Blockbench {
 	/**
 	 * Removes an event listener
 	 */
-	export function removeListener(event_names: EventName): void
+	export function removeListener(event_names: EventName, callback: (data: object) => void): void
 
 
 

package/types/dialog.d.ts

@@ -8,9 +8,22 @@ interface DialogFormElement {
 	readonly?: boolean
 	/** Add buttons to allow copying and sharing the text or link */
 	share_text?: boolean
+	/**
+	 * The default value
+	 */
 	value?: any
+	/**
+	 * The default selected option for 'select', 'inline_select' and 'radio' types. Alias for 'value'
+	 */
+	default?: any
 	placeholder?: string
+	/**
+	 * When using 'text' type, the text to display. Markdown is supported
+	 */
 	text?: string
+	/**
+	 * When using 'range' type, allow users to modify the numeric input
+	 */
 	editable_range_label?: boolean
 	colorpicker?: any
 	min?: number
@@ -19,6 +32,14 @@ interface DialogFormElement {
 	height?: number
 	options?: object
 	buttons?: string[]
+	/**
+	 * Allow users to toggle the entire option on or off
+	 */
+	toggle_enabled?: boolean
+	/**
+	 * Set whether the setting is toggled on or off by default. Requires 'toggle_enabled' field to be set to true
+	 */
+	toggle_default?: boolean
 	click?: (button_index: number) => void
 }
 
@@ -97,6 +118,7 @@ interface DialogOptions {
 	 * Unless set to false, clicking on the darkened area outside of the dialog will cancel the dialog.
 	 */
 	cancel_on_click_outside?: boolean
+	width?: number
 }
 
 declare class Dialog {

package/types/display_mode.d.ts

@@ -1,3 +1,7 @@
+declare const DisplayMode: {
+	slots: string[]
+}
+
 interface DisplaySlotOptions {
 	rotation?: ArrayVector3
 	translation?: ArrayVector3

package/types/io.d.ts

@@ -0,0 +1,2 @@
+
+	declare function autoParseJSON(data: string, feedback?: boolean);

package/types/keyframe.d.ts

@@ -13,14 +13,14 @@ interface KeyframeOptions {
     channel?: string
     data_points: {}[]
     time: number
-    color: number
-    uniform: boolean
-    interpolation: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
-    bezier_linked: boolean
-    bezier_left_time: ArrayVector3
-    bezier_left_value: ArrayVector3
-    bezier_right_time: ArrayVector3
-    bezier_right_value: ArrayVector3
+    color?: number
+    uniform?: boolean
+    interpolation?: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
+    bezier_linked?: boolean
+    bezier_left_time?: ArrayVector3
+    bezier_left_value?: ArrayVector3
+    bezier_right_time?: ArrayVector3
+    bezier_right_value?: ArrayVector3
 }
 type axisLetter = 'x' | 'y' | 'z'
 
@@ -65,4 +65,6 @@ declare class _Keyframe {
         channel?: string | null;
         data_points: object[];
     };
-}
+}
+
+declare function updateKeyframeSelection(): void;

package/types/math_util.d.ts

@@ -0,0 +1 @@
+	declare function guid(): string;

package/types/misc.d.ts

@@ -100,7 +100,7 @@ interface MessageBoxOptions {
 	 * Display a list of actions to do in the dialog. When clicked, the message box closes with the string ID of the command as first argument.
 	 */
 	commands?: {
-		[id: string]: string | {text: string}
+		[id: string]: string | {text: string, icon?: IconString, condition?: ConditionResolvable}
 	}
 	/**
 	 * Adds checkboxes to the bottom of the message box

package/types/mode.d.ts

@@ -31,4 +31,5 @@ declare namespace Modes {
 	const options: {
 		[id: string]: Mode
 	}
+	const selected: Mode;
 }

package/types/plugin.d.ts

@@ -29,7 +29,7 @@ interface PluginOptions {
 	/**
 	 * Set to true if the plugin must finish loading before a project is opened, i. e. because it adds a format
 	 */
-	await_loading?: string
+	await_loading?: boolean
 	/**
 	 * Use the new repository format where plugin, iron, and about are stored in a separate folder
 	 */

package/types/preview.d.ts

@@ -20,7 +20,7 @@ type RaycastResult = {
     intersects?: object[]
     face?: string
     vertex: any
-    keyframe: Keyframe
+    keyframe: _Keyframe
 }
 
 /**

package/types/project.d.ts

@@ -15,6 +15,7 @@ declare class ModelProject {
 	uuid: UUID
 	selected: boolean
 	model_identifier: string
+	parent: string
 	/**
 	 * When set to true, the project tab can no longer be selected or unselected
 	 */
@@ -56,7 +57,7 @@ declare class ModelProject {
 	textures: Texture[]
 	selected_texture: Texture | null;
 	outliner: OutlinerNode[]
-	animations: Animation[]
+	animations: _Animation[]
 	timeline_animators: []
 	display_settings: {
 		[slot: string]: {
@@ -64,8 +65,12 @@ declare class ModelProject {
 			rotation: [number, number, number]
 			scale: [number, number, number]
 			mirror: [boolean, boolean, boolean]
+			export(): void;
 		}
 	};
+	ambientocclusion: boolean;
+	front_gui_light: boolean;
+	overrides: any;
 
 	get model_3d(): THREE.Object3D;
     get materials(): {

package/types/shared_actions.d.ts

@@ -0,0 +1,78 @@
+/**
+ * Shared Actions is a system in Blockbench to allow actions (including in toolbars, menus, via action control, or keybinding) to run different code in different cases, such as in different modes or different panels.
+ * As an example, the "Duplicate" action runs code to duplicate elements when used in the outliner, and duplicates textures when used in the textures panel.
+ * 
+ * 
+ * Handlers can be added for existing actions like this:
+
+### Example:
+
+```javascript
+	// Duplicate layers when using "Duplicate" in the layers panel
+	SharedActions.add('duplicate', {
+		subject: 'layer',
+		condition: () => Prop.active_panel == 'layers' && TextureLayer.selected,
+		run() {
+			let texture = Texture.selected;
+			let original = texture.getActiveLayer();
+			let copy = original.getUndoCopy(true);
+			copy.name += '-copy';
+			Undo.initEdit({textures: [texture]});
+			let layer = new TextureLayer(copy, texture);
+			layer.addForEditing();
+			Undo.finishEdit('Duplicate layer');
+		}
+	})
+```
+ * 
+ */
+declare namespace SharedActions {
+    const checks: {
+		[id: SharedActionID]: SharedActionHandler
+	}
+
+	/**
+	 * Add a new handler to a shared action
+	 * @param action_id Action ID
+	 * @param handler Handler options
+	 */
+	function add(action_id: SharedActionID, handler: SharedActionHandler): Deletable
+	/**
+	 * Run the active handler for a specific subject manually
+	 * @param action_id Action ID
+	 * @param event Event that triggered the interaction
+	 * @param context Optional context variable
+	 */
+	function run(action_id: SharedActionID, event?: Event, context?: any): boolean
+	/**
+	 * Run a specific handler manually
+	 * @param action_id Action ID
+	 * @param subject Subject to run on
+	 * @param event Event that triggered the interaction
+	 * @param context Optional context variable
+	 * @param force Force the specified handler to run and ignore its condition
+	 */
+	function runSpecific(action_id: SharedActionID, subject: string, event?: Event, context?: any, force?: boolean): boolean
+	/**
+	 * Check if there is an active and available handler in the current situation for a shared action
+	 * @param action_id 
+	 */
+	function condition(action_id: SharedActionID): boolean
+	/**
+	 * Find the active handler in the current situation for a shared action
+	 * @param action_id 
+	 * @param event 
+	 * @param context 
+	 */
+	function find(action_id: SharedActionID, event?: Event, context?: any): SharedActionHandler | null
+}
+
+interface SharedActionHandler {
+	priority: number
+	subject: string
+	condition: ConditionResolvable
+	run: (event?: Event, context?: any) => void
+}
+
+type SharedActionID = string | 'rename' | 'delete' | 'duplicate' | 'select_all' | 'unselect_all' | 'invert_selection'
+

package/types/texture_layers.d.ts

@@ -0,0 +1,118 @@
+/// <reference types="three" />
+
+interface TextureLayerData {
+    name?: string
+    in_limbo?: boolean
+    offset?: ArrayVector2
+    scale?: ArrayVector2
+    opacity?: number
+    visible?: boolean
+    blend_mode?: 'default' | 'set_opacity' | 'color' | 'multiply' | 'add' | 'screen' | 'difference'
+    image_data?: ImageData
+    data_url?: string
+}
+
+/**
+ * Texture layers always belong to a texture and represent the layers of the texture. Each layer has its own HTML canvas and canvas context
+ */
+declare class TextureLayer {
+    constructor(data: TextureLayerData, texture: Texture, uuid?: string);
+
+    name: string
+    uuid: UUID
+    texture: Texture
+    canvas: HTMLCanvasElement
+    ctx: CanvasRenderingContext2D
+    in_limbo: boolean
+    img: HTMLImageElement
+    /**
+     * Layer offset from the top left corner of the texture to the top left corner of the layer
+     */
+    offset: ArrayVector2
+    /**
+     * Layer scale. This is only used by the layer transform tool and should be applied and reset to 1x1 before doing further changes
+     */
+    scale: ArrayVector2
+    opacity: number
+    visible: boolean
+    blend_mode: 'default' | 'set_opacity' | 'color' | 'multiply' | 'add' | 'screen' | 'difference'
+
+    extend(data: TextureLayerData): void
+    /**
+     * Selects the layer
+     */
+    select(): void
+    showContextMenu(event: Event): void
+    /**
+     * Remove the layer
+     * @param undo Create an undo point and update the texture
+     */
+    remove(undo: boolean): void
+    getUndoCopy(image_data: boolean): object
+    getSaveCopy(): object
+    /**
+     * Set the layer into a limbo state, where clicking Place or clicking next to the layer will place it on the layer below
+     */
+    setLimbo(): void
+    /**
+     * Resolves the limbo state by turning the limbo layer into a full layer, or merging it into the layer below
+     * @param keep_separate If true, the layer is kept as a separate layer
+     */
+    resolveLimbo(keep_separate): void
+    /**
+     * Set the layer size. This resizes the canvas, which discards the layer content
+     */
+    setSize(width: number, height: number): void
+    /**
+     * Toggle layer visibility. This creates an undo point
+     */
+    toggleVisibility(): void
+    /**
+     * Scroll the layer panel list to 
+     */
+    scrollTo(): void
+    /**
+     * Add the layer to the associated texture above the previously selected layer, select this layer, and scroll the layer panel list to it
+     */
+    addForEditing(): void
+    /**
+     * Merge this texture onto the texture below
+     * @param undo Create an undo entry
+     */
+    mergeDown(undo: boolean): void
+    /**
+     * Expand the layer to include the listed pixels
+     * @param points 
+     */
+    expandTo(...points: ArrayVector2): void
+    /**
+     * Flip the texture along an axis
+     * @param axis Flip axis, where 0 is X and 1 is Y
+     * @param undo Create an undo entry
+     */
+    flip(axis: number, undo): void
+    /**
+     * Rotate the layer around itself in 90 degree steps
+     * @param angle Angle in degrees
+     * @param undo Create an undo entry
+     */
+    rotate(angle: number, undo: boolean): void
+    /**
+     * Centers the layer on the texture
+     */
+    center(): void
+    /**
+     * Open the properties dialog
+     */
+    propertiesDialog(): void
+
+
+    /**
+     * Get all layers of the active texture
+     */
+    static all: TextureLayer[]
+    /**
+     * Get the selected layer
+     */
+    static selected: TextureLayer
+}

package/types/textures.d.ts

@@ -74,20 +74,43 @@ declare class Texture {
     error: number
     /** Whether the texture is visible. Used for layered textures mode */
     visible: boolean
-    /** Whether the texture canvas is displayed in the UV/2D editor, for live feedback */
-    display_canvas: boolean
+
     width: number
     height: number
+    uv_width: number
+    uv_height: number
     currentFrame: number
     saved: boolean
-    /** Whether the latest version of the texture is currently loaded from and linked to a file on disk, or held in memory as bitmap data */
+    /**
+     * Whether the latest version of the texture is currently loaded from and linked to a file on disk, or held in memory as bitmap data
+     * @deprecated Use texture.internal instead
+    */
     mode: 'link' | 'bitmap'
+    /**
+     * If true, the texture is loaded internally. If false, the texture is loaded directly from a file
+     */
+    internal: boolean
     uuid: UUID
+    
+    /**
+     * Texture selection in paint mode
+     */
+    selection: IntMatrix
+    layers: TextureLayer[]
+    layers_enabled: boolean
+    /**
+     * The UUID of the project to sync the texture to
+     */
+    sync_to_project: UUID | ''
 
     /**
-     * The texture's associated canvas. Note: This may not always be up to date with the texture data
+     * The texture's associated canvas. Since 4.9, this is the main source of truth for textures in internal mode.
      */
     canvas: HTMLCanvasElement
+    /**
+     * The 2D context of the texture's associated canvas.
+     */
+    ctx: CanvasRenderingContext2D
     /**
      * Texture image element
      */
@@ -95,6 +118,29 @@ declare class Texture {
 
     getErrorMessage(): string;
     extend(data: TextureData): this;
+
+    /**
+     * Get the UV width of the texture if the format uses per texture UV size, otherwise get the project texture width
+     */
+    getUVWidth(): number
+    /**
+     * Get the UV height of the texture if the format uses per texture UV size, otherwise get the project texture height
+     */
+    getUVHeight(): number
+    getUndoCopy(bitmap?: boolean): object
+    getSaveCopy(bitmap?: boolean): object
+    /**
+     * Start listening for changes to the linked file. Desktop only
+     */
+    startWatcher()
+    /**
+     * Stop listening for changes to the linked file. Desktop only
+     */
+    stopWatcher()
+    /**
+     * Generate the Java Block/Item folder property from the file path
+     */
+    generateFolder()
     /**
      * Loads the texture from it's current source
      * @param cb Callback function
@@ -163,9 +209,13 @@ declare class Texture {
     scrollTo(): void;
     save(as: any): this;
     /**
-     * Returns the content of the texture as a base64 encoded string
+     * Returns the content of the texture as PNG as a base64 encoded string
      */
     getBase64(): string;
+    /**
+     * Returns the content of the texture as PNG as a base64 encoded data URL
+     */
+    getDataURL(): string;
     /**
      * Wrapper to do edits to the texture. 
      * @param callback 
@@ -173,6 +223,54 @@ declare class Texture {
      */
     edit(callback: (instance: HTMLCanvasElement | object) => void | HTMLCanvasElement, options: TextureEditOptions): void;
     menu: Menu
+    /**
+     * Get the selected layer. If no layer is selected, returns the bottom layer
+     */
+    getActiveLayer(): TextureLayer
+    activateLayers(undo?: boolean): void
+    /**
+     * Turns the texture selection into a layer
+     * @param undo Whether to create an undo entry
+     * @param clone When true, the selection is copied into the new layer and also left on the original layer
+     */
+    selectionToLayer(undo?: boolean, clone?: boolean): void
+    javaTextureLink(): string
+
+    getMCMetaContent(): {
+        animation?: {
+            frametime: number
+            width?: number
+            height?: number
+            interpolate?: boolean
+            frames?: number[]
+        }
+    }
+    getAnimationFrameIndices(): number[]
+
+    exportEmissionMap(): void
+
+    convertToInternal(data_url?: string): this
+    /**
+     * Redraws the texture content from the layers
+     * @param update_data_url If true, the texture source gets updated as well. This is slower, but is necessary at the end of an edit. During an edit, to preview changes, this can be false
+     */
+    updateLayerChanges(update_data_url?: boolean): void
+    /**
+     * Update everything after a content edit to the texture or one of the layers. Updates the material, the layers, marks the texture as unsaved, syncs changes to other projects
+     */
+    updateChangesAfterEdit(): void
+    /**
+     * Update the attached img element with the content from the texture's canvas
+     */
+    updateImageFromCanvas(): void
+    /**
+     * If layers are enabled, returns the active layer, otherwise returns the texture. Either way, the 'canvas', 'ctx', and 'offset' properties can be used from the returned object
+     */
+    getActiveCanvas(): Texture | TextureLayer
+    /**
+     * When editing the same texture in different tabs (via Edit In Blockbench option), sync changes that were made to the texture to other projects
+     */
+    syncToOtherProject(): this
 
     static all: Texture[]
     static getDefault(): Texture
@@ -191,6 +289,104 @@ declare function loadTextureDraggable(): void;
  */
 declare function unselectTextures(): void;
 
+/**
+ * An Int Matrix holds an int (unsigned 8 bit) for each pixel in a matrix, via array. The override property can be used to set an override value for the entire area. This is used for texture selections.
+ */
+declare class IntMatrix {
+	constructor(width: number, height: number)
+    width: number
+    height: number
+    array: null | Int8Array
+    /**
+     * The override can be set to true to indicate that the whole texture is selected, or false, which indicates that nothing is selected. Null indicates a custom selection
+     */
+    override: boolean | null
+    /**
+     * True if there is a custom selection
+     */
+	readonly is_custom: boolean
+	/**
+	 * The array does not exist by default to save memory, this activates it.
+	 */
+	activate(): void
+	/**
+	 * Get the value at the specified pixel
+	 * @param {*} x X coordinate
+	 * @param {*} y Y coordinate
+	 * @returns The value of the targeted pixel
+	 */
+	get(x, y): number | boolean
+	/**
+	 * Test whether painting is allowed at a specific pixel
+	 * @param {*} x X coordinate
+	 * @param {*} y Y coordinate
+	 * @returns Boolean or value of the pixel
+	 */
+	allow(x, y): number | boolean
+	/**
+	 * Get the value at the specified pixel directly without override and bounds check
+	 * @param {*} x X coordinate
+	 * @param {*} y Y coordinate
+	 * @returns 
+	 */
+	getDirect(x: number, y: number): number
+    /**
+     * Return the smallest possible rectangle that contains all of the selection
+     * @param respect_empty If true, if there is no selection, the bounding box will still cover the entire area
+     */
+	getBoundingRect(respect_empty): Rectangle
+    /**
+     * Checks whether a selection is present and contains selected pixels
+     */
+	hasSelection(): boolean
+	/**
+	 * Set the value at a specified pixel
+	 * @param {*} x X coordinate
+	 * @param {*} y Y coordinate
+	 * @param {number} value 
+	 */
+	set(x: number, y: number, value: number)
+	/**
+	 * If there was a selection, whether override or not, clear it
+	 */
+	clear(): void
+	/**
+	 * Change override mode
+	 * @param {true|false|null} value 
+	 * @returns 
+	 */
+	setOverride(value: boolean | null): void
+	/**
+	 * Change the size of the matrix. Unless using overrides, the selection gets lost.
+	 * @param {number} width 
+	 * @param {number} height 
+	 * @returns {boolean} Whether the size had to be changed
+	 */
+	changeSize(width: number, height: number): void
+    /**
+     * Run a method on each pixel, whether selected or not
+     * @param callback Function to run per pixel
+     */
+	forEachPixel(callback: ((x: number, y: number, value: number, index: number) => void))
+    /**
+     * Shift custom selections by a specified offset
+     * @param offset_x 
+     * @param offset_y 
+     */
+	translate(offset_x: number, offset_y: number): void
+    /**
+     * Return the selection simplified into non-overlapping boxes. Boxes are [x, y, width, height].
+     */
+	toBoxes(): [number, number, number, number][]
+    /**
+     * Mask the provided canvas using the selection
+     * @param ctx Canvas 2D context
+     * @param offset Position offset of the canvas, e. g. when using a layer
+     */
+	maskCanvas(ctx: CanvasRenderingContext2D, offset: ArrayVector2): void
+}
+
+
 /**
  * Handles playback of animated textures
  */

package/types/timeline.d.ts

@@ -1,6 +1,6 @@
 declare namespace Timeline {
     const animators: GeneralAnimator[]
-    const selected: Keyframe[]
+    const selected: _Keyframe[]
     const playing_sounds: any[]
     let playback_speed: number
     /**
@@ -58,7 +58,7 @@ declare namespace Timeline {
      */
     function pause(): void
 
-    let keyframes: Keyframe[]
+    let keyframes: _Keyframe[]
     let menu: Menu
     function showMenu(event: Event): void
 

package/types/undo.d.ts

@@ -20,9 +20,9 @@ interface UndoAspects {
     selected_texture?: boolean
     settings?: {}
     uv_mode?: boolean
-    animations?: Animation[]
+    animations?: _Animation[]
     animation_controllers?: AnimationController[]
-    keyframes?: Keyframe[]
+    keyframes?: _Keyframe[]
     display_slots?: string[]
     exploded_view?: boolean
 }
@@ -85,7 +85,7 @@ declare class UndoSystem {
      * Add keyframes to the current edit that were indirectly removed by moving other keyframes to their position
      * @param keyframes 
      */
-    addKeyframeCasualties(keyframes: Keyframe[]): void;
+    addKeyframeCasualties(keyframes: _Keyframe[]): void;
     /**
      * Undoes the latest edit
      */

package/types/util.d.ts

@@ -83,3 +83,20 @@ declare namespace Merge {
 	function arrayVector(target: object, source: object, key: string|number, validate?: ((value) => boolean)): void
 	function arrayVector2(target: object, source: object, key: string|number, validate?: ((value) => boolean)): void
 }
+
+declare class Rectangle {
+	constructor(start_x: number, start_y: number, width: number, height: number)
+    start_x: number
+    start_y: number
+    width: number
+    height: number
+	readonly start: ArrayVector2
+	readonly w: number
+	readonly h: number
+	end_x: number
+	end_y: number
+	readonly area: number
+	fromCoords(x1: number, y1: number, x2: number, y2: number): void
+	fromUnorderedCoords(x1: number, y1: number, x2: number, y2: number): void
+	expandTo(x: number, y: number): void
+}