blockbench-types 4.6.1 → 4.8.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "blockbench-types",
-  "version": "4.6.1",
+  "version": "4.8.0",
   "description": "Blockbench typescript types",
   "main": "",
   "types": "types/blockbench.d.ts",
@@ -22,6 +22,7 @@
   },
   "dependencies": {
     "@types/jquery": "^3.5.4",
+    "@types/three": "^0.155.0",
     "@types/tinycolor2": "^1.4.3",
     "three": "^0.129.0",
     "typescript": "^4.9.5",

package/scripts/generate_docs.js

@@ -68,13 +68,13 @@ async function main() {
 
 		'Vue.Component': '[Vue.Component](https://v2.vuejs.org/v2/guide/components.html)',
 
-		'THREE.Vector3': '[THREE.Vector3](https://threejs.org/docs/index.html#api/en/math/Vector3)',
-		'THREE.Euler': '[THREE.Euler](https://threejs.org/docs/index.html#api/en/math/Euler)',
-		'THREE.Quaternion': '[THREE.Quaternion](https://threejs.org/docs/index.html#api/en/math/Quaternion)',
-		'THREE.Object3D': '[THREE.Object3D](https://threejs.org/docs/index.html#api/en/core/Object3D)',
-		'THREE.PerspectiveCamera': '[THREE.PerspectiveCamera](https://threejs.org/docs/index.html#api/en/cameras/PerspectiveCamera)',
-		'THREE.OrthographicCamera': '[THREE.OrthographicCamera](https://threejs.org/docs/index.html#api/en/cameras/OrthographicCamera)',
-		'THREE.WebGLRenderer': '[THREE.WebGLRenderer](https://threejs.org/docs/index.html#api/en/renderers/WebGLRenderer)',
+		'Vector3': '[THREE.Vector3](https://threejs.org/docs/index.html#api/en/math/Vector3)',
+		'Euler': '[THREE.Euler](https://threejs.org/docs/index.html#api/en/math/Euler)',
+		'Quaternion': '[THREE.Quaternion](https://threejs.org/docs/index.html#api/en/math/Quaternion)',
+		'Object3D': '[THREE.Object3D](https://threejs.org/docs/index.html#api/en/core/Object3D)',
+		'PerspectiveCamera': '[THREE.PerspectiveCamera](https://threejs.org/docs/index.html#api/en/cameras/PerspectiveCamera)',
+		'OrthographicCamera': '[THREE.OrthographicCamera](https://threejs.org/docs/index.html#api/en/cameras/OrthographicCamera)',
+		'WebGLRenderer': '[THREE.WebGLRenderer](https://threejs.org/docs/index.html#api/en/renderers/WebGLRenderer)',
 
 		'HTMLElement': '[HTMLElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLElement)',
 		'HTMLCanvasElement': '[HTMLCanvasElement](https://developer.mozilla.org/en-US/docs/Web/API/HTMLCanvasElement)',

package/types/action.d.ts

@@ -31,6 +31,7 @@ declare class KeybindItem extends Deletable {
 declare class MenuSeparator {
     constructor();
 }
+type ActionEventName = 'delete' | 'use' | 'used' | 'trigger' | 'get_node' | 'select' | 'change' | 'changed' | 'update' | 'open'
 interface BarItemOptions extends KeybindItemOptions {
     name?: string
     description?: string
@@ -60,6 +61,26 @@ declare class BarItem extends KeybindItem {
      */
     toElement(destination: HTMLElement): this;
     pushToolbar(bar: any): void;
+
+    /**
+	 * Adds an event listener to the item
+	 * @param event_name The event type to listen for
+	 * @param callback 
+	 */
+	on(event_name: ActionEventName, callback: (data: object) => void): void
+	/**
+	 * Adds a single-use event listener to the item
+	 * @param event_name The event type to listen for
+	 * @param callback 
+	 */
+	once(event_name: ActionEventName, callback: (data: object) => void): void
+	/**
+	 * Removes an event listener from the item
+	 * @param event_name 
+	 * @param callback 
+	 */
+	removeListener(event_name: ActionEventName, callback: (data: object) => void): void
+	dispatchEvent(data: object): void
 }
 
 interface ActionOptions extends BarItemOptions {
@@ -230,7 +251,7 @@ interface ToolOptions extends ActionOptions {
     brush?: BrushOptions
 }
 /**
- * A tool, such as mvoe tool, vertex snap tool, or paint brush
+ * A tool, such as move tool, vertex snap tool, or paint brush
  */
 declare class Tool extends Action {
     constructor(id: string, options: ToolOptions);
@@ -284,8 +305,27 @@ declare class ColorPicker extends Widget {
     set(color: any): this;
     get(): any;
 }
+interface ToolbarOptions {
+    id: string
+    name?: string
+    /**
+     * If true, the toolbar will display a label abovee
+     */
+    label?: boolean
+    condition?: ConditionResolvable
+    /**
+     * If true, the toolbar will only take as much width as needed
+     */
+    narrow?: boolean
+    vertical?: boolean
+    /**
+     * Default content of the toolbar. Separators are available, where _ = separator, + = spaces, # = line break
+     */
+    children: ('_' | '+' | '#' | string | BarItem)[]
+}
 declare class Toolbar {
-    constructor(data: any);
+    constructor(id: string, data: ToolbarOptions);
+    constructor(data: ToolbarOptions);
     build(data: any, force: any): this;
     contextmenu(event: Event): void;
     editMenu(): this;

package/types/animation.d.ts

@@ -27,6 +27,9 @@ declare class _Animation extends AnimationItem {
         snapping: any;
         selected: any;
     };
+    /**
+     * Compiles the JSON tree of the animation for the Minecraft Bedrock Edition animation format.
+     */
     compileBedrockAnimation(): object;
     save(): this | undefined;
     select(): this | undefined;
@@ -35,12 +38,25 @@ declare class _Animation extends AnimationItem {
     rename(): this;
     togglePlayingState(state: any): any;
     showContextMenu(event: any): this;
-    getBoneAnimator(group: any): BoneAnimator;
+    /**
+     * Returns (if necessary creates) the animator of a specific bone of the animation
+     */
+    getBoneAnimator(group: OutlinerNode): BoneAnimator;
+    /**
+     * 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;
     remove(undo: any, remove_from_file?: boolean): this;
     getMaxLength(): number;
     setLoop(value: any, undo: any): void;
+    /**
+     * Calculate the snapping value that the animation should use, based on the time codes of the keyframes that it holds. Directly updates the value, but also returns it as a number (snaps per second)
+     */
     calculateSnappingFromKeyframes(): number;
+    /**
+     * Opens the properties dialog
+     */
     propertiesDialog(): void;
 
     name: string
@@ -142,9 +158,9 @@ declare class NullObjectAnimator extends GeneralAnimator {
 declare class EffectAnimator extends GeneralAnimator {
     name: string
     uuid: string
-    rotations: Keyframe[]
-    position: Keyframe[]
-    scale: Keyframe[]
+    particle: Keyframe[]
+    sound: Keyframe[]
+    timeline: Keyframe[]
     pushKeyframe(keyframe): this
     displayFrame(in_loop): this
     startPreviousSounds(): void

package/types/animation_controller.d.ts

@@ -80,7 +80,9 @@ interface AnimationControllerOptions {
     initial_state?: string
 }
 
-
+/**
+ * Animation Controllers are state machines used for Minecraft: Bedrock Edition models to control and blend between animations.
+ */
 declare class AnimationController extends AnimationItem {
     constructor(data: AnimationControllerOptions);
     name: string
@@ -100,6 +102,10 @@ declare class AnimationController extends AnimationItem {
     select(): this | undefined;
     createUniqueName(references: AnimationController[]): string | boolean;
     rename(): this;
+    /**
+     * Adds the animation controller to the current project and to the interface
+     * @param undo If true, the addition of the animation controller will be registered as an edit
+     */
     add(undo: any): this;
     remove(undo?: boolean, remove_from_file?: boolean): this;
     propertiesDialog(): void;

package/types/blockbench.d.ts

@@ -1,5 +1,5 @@
 /// <reference types="vue" />
-/// <reference types="three" />
+/// <reference types="@types/three" />
 /// <reference types="@types/tinycolor2" />
 /// <reference types="@types/jquery" />
 /// <reference types="wintersky" />
@@ -35,6 +35,7 @@
 /// <reference types="./display_mode" />
 /// <reference types="./misc" />
 /// <reference types="./util" />
+/// <reference types="./canvas_frame" />
 
 
 	
@@ -58,7 +59,7 @@ type WriteType = 'buffer' | 'text' | 'zip' | 'image'
 interface WriteOptions {
 	content: string | ArrayBuffer
 	savetype?: WriteType | ((file: string) => WriteType)
-	custom_writer(content: string | ArrayBuffer, file_path: string): void
+	custom_writer?(content: string | ArrayBuffer, file_path: string): void
 }
 interface PickDirOptions {
 	/**Location where the file dialog starts off
@@ -204,9 +205,13 @@ declare namespace Blockbench {
 	/**
 	 * Opens a message box
 	 */
-	export function showMessageBox(options: MessageBoxOptions, callback: (buttonID: number | string) => void): void
+	export function showMessageBox(options: MessageBoxOptions, callback: (button: number | string, checkbox_results: {[key: string]: boolean} | undefined, event: Event) => void): void
 
 	export function textPrompt(title: string, value: string, callback: (value: string) => void): void
+	/**
+	 * todo
+	 */
+	export function showToastMessage(): Deletable
 	/**
 	 * Opens the specified link in the browser or in a new tab
 	 */
@@ -232,8 +237,17 @@ declare namespace Blockbench {
 	export function dispatchEvent(event_name: EventName, data: object): void
 
 	export function addListener(event_names: EventName, callback: (data: object) => void): void
+	/**
+	 * Adds an event listener
+	 */
 	export function on(event_names: EventName, callback: (data: object) => void): void
-
+	/**
+	 * Adds a single-use event listener
+	 */
+	export function once(event_names: EventName, callback: (data: object) => void): void
+	/**
+	 * Removes an event listener
+	 */
 	export function removeListener(event_names: EventName): void
 
 
@@ -274,6 +288,22 @@ declare namespace Blockbench {
 	export { _export as export };
 
 
+	interface FindFileFromContentOptions {
+		read_file?: boolean
+		json?: boolean
+		recursive?: boolean
+		filter_regex?: RegExp
+		priority_regex?: RegExp
+	}
+	type CheckFileCallback = (path: string, content: (string|object)) => any
+	/**
+	 * Find a file in a directory, based on content. Optimized by prioritizing files with certain names.
+	 * @param base_directories Base directories to search in
+	 * @param options Options
+	 * @param check_file Function that runs on every file to check if the file is a match. If the function returns anything truthy, that result is returned by the main function.
+	 */
+	export function findFileFromContent(base_directories: string[], options: FindFileFromContentOptions, check_file: CheckFileCallback): false | any
+
 
 	/**
 	 * Adds a drag handler that handles dragging and dropping files into Blockbench

package/types/canvas.d.ts

@@ -38,6 +38,9 @@ interface UpdateViewOptions {
     selection?: boolean
 }
 
+/**
+ * A global namespace handling miscellaneous functionality related to the 3D preview
+ */
 declare namespace Canvas {
     const materials: {
         [uuid: UUID]: THREE.Material
@@ -230,7 +233,17 @@ declare class NodePreviewController {
         [event_name: string]: ((data) => void)[]
     }
     dispatchEvent(event_name: string, data: object)
+	/**
+	 * Adds an event listener
+	 */
     on(event_name: string, cb: (data) => void)
+	/**
+	 * Adds a single-use event listener
+	 */
+    once(event_name: string, cb: (data) => void)
+	/**
+	 * Removes an event listener
+	 */
     removeListener(event_name: string, cb: (data) => void)
 
     setup(element: OutlinerNode): void

package/types/canvas_frame.d.ts

@@ -0,0 +1,21 @@
+/**
+ * Wrapper for HTML canvases to simplify loading and modifying images
+ */
+declare class CanvasFrame {
+	readonly width: number
+	readonly height: number
+	canvas: HTMLCanvasElement
+	ctx: CanvasRenderingContext2D
+
+	constructor(a: HTMLCanvasElement)
+	constructor(a: HTMLImageElement)
+	constructor(a: number, b: number)
+
+	createCanvas(width: number, height: number): void
+	loadFromUrl(url: string): Promise<void>
+	loadFromImg(img: HTMLImageElement): void
+	/**
+	 * Crop the image to only pixels that have an alpha value
+	 */
+	autoCrop(): void
+}

package/types/codec.d.ts

@@ -25,6 +25,15 @@ interface CodecOptions {
 		type: 'json' | 'text'
 		condition?: ConditionResolvable
 	}
+	/**
+	 * List of export option inputs, based on the Dialog form API
+	 */
+	export_options?: {
+		[key: string]: DialogFormElement
+	}
+	/**
+	 * Default action that is used to export to the codec
+	 */
 	export_action?: Action
 }
 
@@ -79,12 +88,27 @@ declare class Codec extends Deletable {
 	afterDownload?(path): void
 	afterSave?(path): void
 
+	/**
+	 * Return the stored export option values of the current project
+	 */
+	getExportOptions(): {[key: string]: any}
+	/**
+	 * Prompt the user to enter their preferred export settings into the dialog
+	 */
+	promptExportOptions(): Promise<({[key: string]: any} | null)>
+
 	/**
 	 * Adds an event listener to the codec
 	 * @param event_name The event type to listen for
 	 * @param callback 
 	 */
 	on(event_name: string, callback: (data: object) => void): void
+	/**
+	 * Adds a single-use event listener to the codec
+	 * @param event_name The event type to listen for
+	 * @param callback 
+	 */
+	once(event_name: string, callback: (data: object) => void): void
 	/**
 	 * Removes an event listener from the codec
 	 * @param event_name 
@@ -110,6 +134,13 @@ declare class Codec extends Deletable {
 	 */
 	export_action?: Action
 
+	/**
+	 * List of export option inputs
+	 */
+	export_options: {
+		[key: string]: DialogFormElement
+	}
+
 	/**
 	 * Get a list of all possible extensions of all codecs
 	 */

package/types/cube.d.ts

@@ -80,11 +80,14 @@ declare class Cube extends OutlinerElement {
 
 	static all: Cube[]
 	static selected: Cube[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 interface FaceOptions {
 	texture?: Texture
-
 }
 declare class Face {
 	constructor()

package/types/dialog.d.ts

@@ -1,5 +1,5 @@
 interface DialogFormElement {
-	type: 'text' | 'number' | 'range' | 'checkbox' | 'select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info' | 'buttons'
+	type: 'text' | 'number' | 'range' | 'checkbox' | 'select' | 'inline_select' | 'radio' | 'textarea' | 'vector' | 'color' | 'file' | 'folder' | 'save' | 'info' | 'buttons'
 	label?: string
 	description?: string
 	nocolon?: boolean

package/types/display_mode.d.ts

@@ -5,6 +5,9 @@ interface DisplaySlotOptions {
 	mirror?: [boolean, boolean, boolean]
 }
 
+/**
+ * Display Slots hold the transform values for a specific item slot in the Minecraft Java Edition "Display Mode" feature
+ */
 declare class DisplaySlot {
 	constructor(id: string, data: DisplaySlotOptions)
 	rotation: ArrayVector3

package/types/format.d.ts

@@ -56,6 +56,7 @@ interface FormatOptions {
 	bone_rig?: boolean
 	centered_grid?: boolean
 	rotate_cubes?: boolean
+	stretch_cubes?: boolean
 	integer_size?: boolean
 	meshes?: boolean
 	texture_meshes?: boolean
@@ -108,6 +109,7 @@ declare class ModelFormat extends Deletable {
 	bone_rig: boolean
 	centered_grid: boolean
 	rotate_cubes: boolean
+	stretch_cubes: boolean
 	integer_size: boolean
 	meshes: boolean
 	texture_meshes: boolean

package/types/global.d.ts

@@ -16,11 +16,17 @@ declare global {
 		 * Rounds the input number to N digits
 		 */
 		roundTo(number: number, digits: number): number
+		/**
+		 * Test if the number is between two other numbers
+		 */
 		isBetween(number: number, limit1: number, limit2: number): boolean
 		/**
 		 * Checks if the absolute difference between a and b is smaller than epsilon
 		 */
 		epsilon(a: number, b: number, epsilon: number): boolean
+		/**
+		 * Take a rotation value in degrees, and trim it to a value between -180 and 180, while keeping the same angle
+		 */
 		trimDeg(degrees: number): number
 		isPowerOfTwo(number: number): boolean
 		/***
@@ -32,8 +38,30 @@ declare global {
 		 */
 		randomab(a: number, b: number): number
 		areMultiples(number1: number, number2: number): boolean
+		/**
+		 * Return the next highest power of n
+		 * @param num Power
+		 * @param min Value that the result should be equal to or higher than
+		 */
 		getNextPower(num: number, min: number): number
+		/**
+		 * Snap the value to the closest number in a list of 1 or more snap points
+		 */
 		snapToValues(number: number, snap_points: number[], epsilon: number): number
+		/**
+		 * Get the lerp alpha value of m, between points a and b
+		 */
+		getLerp: (a: number, b: number, m: number) => number
+		/**
+		 * Lerp between a and b using the 0-1 alpha value
+		 */
+		lerp: (a: number, b: number, alpha: number) => number
+		/**
+		 * Return a random integer
+		 */
+		randomInteger: (a: number, b: number) => number
+		hermiteBlend: (input: number) => number
+		clamp: (number: number, min: number, max: number) => number
 	}
 	interface Array<T> {
 		remove(item: any): boolean

package/types/group.d.ts

@@ -23,6 +23,8 @@ declare class Group extends OutlinerNode {
 	constructor (options: Partial<GroupOptions>)
 	static selected: Group
 	static all: Group[]
+	/**Check if any groups are in the project */
+	static hasAny: () => boolean
 
 	name: string
 	children: OutlinerNode[]

package/types/keyframe.d.ts

@@ -1,11 +1,26 @@
+interface KeyframeDataPointData {
+    [key: string]: any
+}
 declare class KeyframeDataPoint {
     constructor(keyframe: _Keyframe);
-    extend(data: any): void;
-    getUndoCopy(): {};
+    extend(data: KeyframeDataPointData): void;
+    getUndoCopy(): {
+        [key: string]: any
+    };
 }
 
 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
 }
 type axisLetter = 'x' | 'y' | 'z'
 
@@ -13,6 +28,14 @@ declare class _Keyframe {
     constructor(options: KeyframeOptions, uuid: any);
 
     animator: GeneralAnimator;
+
+    channel: string
+    data_points: KeyframeDataPoint[]
+    time: number
+    color: number
+    uniform: boolean
+    interpolation: 'linear' | 'catmullrom' | 'bezier' | 'step' | string
+    bezier_linked: boolean
     bezier_left_time: ArrayVector3;
     bezier_right_time: ArrayVector3;
     bezier_left_value: ArrayVector3;

package/types/menu.d.ts

@@ -22,6 +22,9 @@ interface MenuOptions {
     keep_open?: boolean
     searchable?: boolean
 }
+/**
+ * Use the Menu class to create a context menu. Menus can contain custom entries and hierarchy, or existing actions and tools.
+ */
 declare class Menu extends Deletable {
     constructor(id: string, template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions)
     constructor(template: MenuItem[] | ((context?: any) => MenuItem[]), options?: MenuOptions)
@@ -78,12 +81,12 @@ declare namespace MenuBar {
     /**
      * Adds an action to the menu structure
      * @param action Action to add
-     * @param path Path pointing to the location. Use the ID of each level of the menu, or index within a level, separated by a point. For example, `file.export.0` places the action at the top position of the Export submenu in the File menu.
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index or group within a level, separated by a point. For example, `file.export.0` places the action at the top position of the Export submenu in the File menu.
      */
     function addAction(action: Action, path?: string): void
     /**
      * 
-     * @param path Path pointing to the location. Use the ID of each level of the menu, or index within a level, or item ID, separated by a point. For example, `export.export_special_format` removes the action "Export Special Format" from the Export submenu.
+     * @param path Path pointing to the location. Use the ID of each level of the menu, or index or group within a level, or item ID, separated by a point. For example, `export.export_special_format` removes the action "Export Special Format" from the Export submenu.
      */
     function removeAction(path: string)
     /**

package/types/mesh.d.ts

@@ -71,10 +71,15 @@ declare class Mesh extends OutlinerElement {
 
 	static all: Mesh[]
 	static selected: Mesh[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 interface MeshFaceOptions extends FaceOptions {
-
+	vertices: string[]
+	uv: {[vkey: string]: ArrayVector2}
 }
 declare class MeshFace extends Face {
 	constructor(mesh: Mesh, data: MeshFaceOptions)

package/types/misc.d.ts

@@ -29,12 +29,16 @@ type EventName = 'remove_animation'
 	| 'reset_project'
 	| 'close_project'
 	| 'saved_state_changed'
+	| 'save_model_action'
 	| 'add_cube'
 	| 'add_mesh'
 	| 'add_group'
 	| 'add_texture_mesh'
 	| 'group_elements'
 	| 'update_selection'
+	| 'compile_bedrock_animations'
+	| 'load_animation'
+	| 'load_animation_controller'
 	| 'update_keyframe_selection'
 	| 'select_all'
 	| 'added_to_selection'
@@ -98,10 +102,20 @@ interface MessageBoxOptions {
 	commands?: {
 		[id: string]: string | {text: string}
 	}
+	/**
+	 * Adds checkboxes to the bottom of the message box
+	 */
+	checkboxes: {
+		[id: string]: string | {
+			value?: boolean
+			condition: ConditionResolvable
+			text: string
+		}
+	}
 }
 
 
-
+type PropertyType = 'string' | 'number' | 'enum' | 'molang' | 'boolean' | 'array' | 'instance' | 'vector' | 'vector2'
 interface PropertyOptions {
 	default?: any
 	condition?: ConditionResolvable
@@ -111,6 +125,10 @@ interface PropertyOptions {
 	 * Options used for select types
 	 */
 	options?: object
+	/**
+	 * Enum possible values
+	 */
+	values: string[]
 	merge?: (instance: any, data: object) => void
 	reset?: (instance: any) => void
 	merge_validation?: (value: any) => boolean
@@ -119,20 +137,23 @@ interface PropertyOptions {
  * Creates a new property on the specified target class
  */
 declare class Property extends Deletable {
-    constructor(target_class: any, type: string, name: string, options?: PropertyOptions);
+    constructor(target_class: any, type: PropertyType, name: string, options?: PropertyOptions);
     class: any;
     name: string;
-    type: string;
+    type: PropertyType;
 	default: any;
 	
     isString: boolean;
+    isEnum: boolean;
     isMolang: boolean;
     isNumber: boolean;
     isBoolean: boolean;
     isArray: boolean;
     isVector: boolean;
 	isVector2: boolean;
+	isInstance: boolean;
 	
+	enum_values?: string[]
     merge_validation: undefined | ((value: any) => boolean);
     condition: ConditionResolvable;
     exposed: boolean;

package/types/outliner.d.ts

@@ -9,6 +9,7 @@ type ArrayVector2 = [number, number]
 declare class OutlinerNode {
 	constructor ()
 	uuid: UUID
+	name: string
 	export: boolean
 	locked: boolean
 	parent: Group | 'root'
@@ -53,6 +54,10 @@ declare class OutlinerNode {
 	 * @param event Mouse event, determines where the context menu spawns.
 	 */
 	showContexnu(event: Event | HTMLElement): this
+
+	static uuids: {
+		[uuid: UUID]: OutlinerNode
+	}
 }
 
 /**
@@ -81,6 +86,10 @@ declare class Locator extends OutlinerElement {
 
 	static all: Locator[]
 	static selected: Locator[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 
@@ -103,6 +112,10 @@ declare class NullObject extends OutlinerElement {
 
 	static all: NullObject[]
 	static selected: NullObject[]
+	/**Check if any elements of the type are in the project */
+	static hasAny: () => boolean
+	/**Check if any elements of the type are currently selected */
+	static hasSelected: () => boolean
 }
 
 

package/types/painter.d.ts

@@ -1,4 +1,6 @@
-
+/**
+ * A global namespace containing various functionality for Blockbench's 2D and 3D paint tools and texture editor
+ */
 declare namespace Painter {
 	const currentPixel: ArrayVector2
 	const brushChanges: boolean

package/types/panel.d.ts

@@ -1,3 +1,5 @@
+type PanelSlot = 'left_bar' | 'right_bar' | 'top' | 'bottom' | 'float'
+
 interface PanelOptions {
 	id: string
 	name: string
@@ -10,9 +12,9 @@ interface PanelOptions {
 	expand_button: boolean
 	toolbars: {
 		[id: string]: Toolbar
-	}
+	} | Toolbar[]
 	default_position: {
-		slot: string
+		slot: PanelSlot
 		float_position: [number, number]
 		float_size: [number, number]
 		height: number
@@ -27,25 +29,38 @@ interface PanelOptions {
 }
 type PanelEvent = 'drag' | 'fold' | 'change_zindex' | 'move_to' | 'moved_to' | 'update'
 
+/**
+ * Panels are interface sections in Blockbench, that are always visible (in a specific format and mode), and can be added to the sidebars, above or below the 3D viewport, or used as free floating above the UI. Examples are the Outliner or the UV editor.
+ */
 declare class Panel {
 	constructor (id: string, options: PanelOptions)
 	constructor (options: PanelOptions)
 	isVisible(): boolean
 	isInSidebar(): boolean
-	slot: string
+	slot: PanelSlot
 	folded: boolean
+	inside_vue: Vue
+
+
 	fold(state?: boolean): this
 	/**
 	 * If the panel is floating, move it up to the front
 	 */
 	moveToFront(): this
-	moveTo(slot: string, ref_panel?: Panel, before?: boolean): this
+	moveTo(slot: PanelSlot, ref_panel?: Panel, before?: boolean): this
 	update(dragging?: boolean): this
 	dispatchEvent(event_name: PanelEvent, data?: any): void
 	/**
 	 * Add an event listener
 	 */
 	on(event_name: PanelEvent, callback: (data?) => void): void
+	/**
+	 * Adds a single-use event listener
+	 */
+	once(event_name: PanelEvent, callback: (data?) => void): void
+	/**
+	 * Removes an event listener
+	 */
 	removeListener(event_name: PanelEvent, callback: (data?) => void): void
 	delete(): void
 }

package/types/plugin.d.ts

@@ -30,6 +30,10 @@ 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
+	/**
+	 * Use the new repository format where plugin, iron, and about are stored in a separate folder
+	 */
+	new_repository_format?: boolean
 	/**
 	 * Runs when the plugin loads
 	 */

package/types/preview.d.ts

@@ -23,6 +23,9 @@ type RaycastResult = {
     keyframe: Keyframe
 }
 
+/**
+ * Previews are 3D viewports, that can either be used as a viewport for the user, or as an offscreen view to record media.
+ */
 declare class Preview extends Deletable {
     constructor(options: PreviewOptions)
 

package/types/project.d.ts

@@ -2,6 +2,9 @@ interface ModelProjectOptions {
 	format: ModelFormat
 }
 
+/**
+ * A project instance. The tab bar can be used to switch between projects.
+ */
 declare class ModelProject {
 	constructor(options: ModelProjectOptions)
 
@@ -82,13 +85,19 @@ declare class ModelProject {
 	static all: ModelProject[]
 }
 
-declare const Project: ModelProject | null
+/**
+ * Global variable and shortcut to get the currently opened project. If no project is open, or the New Tab is open, this value is falsy.
+ */
+declare const Project: ModelProject | 0
 
 declare function setupProject(format: ModelFormat | string): boolean;
 declare function newProject(format: ModelFormat | string): boolean;
 declare function setProjectResolution(width: number, height: number, modify_uv?: boolean): void;
 declare function updateProjectResolution(): void;
 
+/**
+ * An edit session instance. Edit sessions can be attached to a project to collaborate on it with multiple users via P2P connections.
+ */
 declare class EditSession {
 	constructor()
 

package/types/screencam.d.ts

@@ -28,6 +28,9 @@ interface RecordTimelapseOptions {
 }
 type ScreenshotReturn = (dataURL: string) => void
 
+/**
+ * A global namespace handling screenshot and GIF recording utilities.
+ */
 declare namespace Screencam {
 	/**
 	 * Provided preview with anti aliasing disabled that can be used for screenshots

package/types/settings.d.ts

@@ -1,7 +1,3 @@
-declare const settings: {
-    [id: string]: Setting
-};
-
 interface SettingOptions {
     name: string
     type?: 'number' | 'string' | 'boolean' | 'password' | 'select' | 'click'
@@ -21,10 +17,58 @@ interface SettingOptions {
     onChange?: (value: any) => void
 }
 
+/**
+ * Settings can be used to add global configuration options to Blockbench. All settings are listed under File > Preferences > Settings.
+ */
 declare class Setting extends Deletable {
     constructor(id: string, options: SettingOptions);
 
+    id: string
+    type: string
+    condition: any
+    /**
+     * The master value, not affected by profiles
+     */
+    master_value: any
+    /**
+     * The active value
+     */
+    value: any
+    /**
+     * The value that is displayed in the settings dialog
+     */
+    ui_value: any
+    name: string
+    description: string
+    category: string
+    /**
+     * If true, the setting can be used by the main process before initializing the Blockbench window. This is not available to custom settings created by plugins.
+     */
+    launch_setting: boolean
+    min?: number
+    max?: number
+    step?: number
+    icon?: string
+    options?: {
+        [id: string]: string
+    }
+    hidden?: boolean
+    onChange?: () => {}
+
+    /**
+     * Sets the value of the setting, while triggering the onChange function if available, and saving the change.
+     */
+    set(value): void
+    /**
+     * Triggers the setting, as if selected in action control. This toggles boolean settings, opens a dialog for string or numeric settings, etc.
+     */
+    trigger(event?: Event): void
+
+
 }
+/**
+ * Global namespace handling data and functionality related to settings.
+ */
 declare namespace Settings {
     const structure: {};
     const stored: {};
@@ -48,4 +92,8 @@ declare namespace Settings {
      * Returns the value of the specified setting
      */
     function get(setting_id: string): any;
-}
+}
+
+declare const settings: {
+    [id: string]: Setting
+};

package/types/textures.d.ts

@@ -38,12 +38,61 @@ interface TextureEditOptions {
     no_undo_finish?: boolean
 }
 
+/**
+ * A texture combines the functionality of material, texture, and image, in one. Textures can be linked to files on the local hard drive, or hold the information in RAM.
+ */
 declare class Texture {
     constructor(data: TextureData, uuid?: string);
     readonly frameCount: number | undefined;
     readonly display_height: number;
     readonly ratio: number;
 
+    path: string
+    name: string
+    /** Relative path to the file's directory, used by some formats such as Java Block/Item*/
+    folder: string
+    namespace: string
+    /** Texture ID or key, used by some formats. By default this is a number that increases with every texture that is added */
+    id: string
+    /** Whether the texture is used for the models particle system. Used by some formats such as Java Block/Item */
+    particle: boolean
+    render_mode: 'default' | 'emissive' | 'additive' | 'layered' | string
+    render_sides: 'auto' | 'front' | 'double' | string
+
+    /** Texture animation frame time */
+    frame_time: number
+    frame_order_type: 'custom' | 'loop' | 'backwards' | 'back_and_forth'
+    /** Custom frame order */
+    frame_order: string
+    /** Interpolate between frames */
+    frame_interpolate: boolean
+
+    /** HTML-style source of the texture's displayed data. Can be a path (desktop app only), or a base64 data URL */
+    source: string
+    selected: boolean
+    show_icon: boolean
+    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
+    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 */
+    mode: 'link' | 'bitmap'
+    uuid: UUID
+
+    /**
+     * The texture's associated canvas. Note: This may not always be up to date with the texture data
+     */
+    canvas: HTMLCanvasElement
+    /**
+     * Texture image element
+     */
+    img: HTMLImageElement
+
     getErrorMessage(): string;
     extend(data: TextureData): this;
     /**

package/types/undo.d.ts

@@ -55,11 +55,11 @@ type UndoEntry = {
 }
 interface AmendEditForm {
     condition?: ConditionResolvable
-    type?: 'number'
+    type?: 'number' | 'checkbox'
     label: string
     interval_type: 'position' | 'rotation'
     getInterval?: (Event) => number
-    value?: number | string,
+    value?: number | string | 'boolean',
     min?: number,
     max?: number,
     step?: number,

package/types/util.d.ts

@@ -54,6 +54,9 @@ declare function getAxisLetter(axisNumber: number): string
 declare function getAxisNumber(axisLetter: string): number
 
 
+/**
+ * Reusable data types that can be used by anything, but should not be used to store data between function calls. Can be used to save memory on frequent function calls.
+ */
 declare namespace Reusable {
 	const vec1: THREE.Vector3
 	const vec2: THREE.Vector3
@@ -68,3 +71,15 @@ declare namespace Reusable {
 	const euler1: THREE.Euler
 	const euler2: THREE.Euler
 }
+
+/**
+ * Merge the value under a certain key from one object into another
+ */
+declare namespace Merge {
+	function number(target: object, source: object, key: string|number): void
+	function string(target: object, source: object, key: string|number, validate?: ((value) => boolean)): void
+	function molang(target: object, source: object, key: string|number): void
+	function boolean(target: object, source: object, key: string|number, validate?: ((value) => boolean)): void
+	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
+}

package/types/validator.d.ts

@@ -1,3 +1,6 @@
+/**
+ * The validator in Blockbench provides feedback about the model and can detect issues in real time, based on a list of checks that can be added. This is a good way to ensure model files are valid, and to teach users about best practices.
+ */
 declare namespace Validator {
     const checks: ValidatorCheck[]
 
@@ -42,6 +45,38 @@ interface WarningOrError {
 		click(): void
 	}[]
 }
+
+/**
+ * A check for the validator. A check can be triggered by certain things, and updates the list of warnings and errors that can be displayed in the status bar.
+
+
+### Example:
+
+```javascript
+	new ValidatorCheck('special_cube_name_rule', {
+		update_triggers: ['update_selection'],
+		run() {
+			Cube.all.forEach(cube => {
+				if (cube.name == 'sphere') {
+					this.warn({
+						message: `The cube "${cube.name}" has an invalid names. Cubes may not be called "sphere".`,
+						buttons: [
+							{
+								name: 'Select Cube',
+								icon: 'fa-cube',
+								click() {
+									Validator.dialog.hide();
+									cube.select();
+								}
+							}
+						]
+					})
+				}
+			})
+		}
+	})
+```
+ */
 declare class ValidatorCheck extends Deletable {
 	constructor(id: string, options: ValidatorCheckOptions)