blockbench-types 5.0.6 → 5.1.0-beta.0-next.1

package/generated/interface/settings.d.ts

@@ -152,4 +152,50 @@ declare global {
         old: {};
     };
 }
+declare const globals: {
+    settings: Record<string, Setting>;
+    Setting: typeof import("./settings").Setting;
+    SettingsProfile: typeof import("./settings").SettingsProfile;
+    Settings: {
+        profile_menu_button: HTMLElement | null;
+        structure: Record<string, {
+            name: string;
+            open: boolean;
+            items: Record<string, Setting>;
+        }>;
+        stored: Record<string, SettingsValue>;
+        dialog: Dialog | null;
+        addCategory(id: string, data: {
+            name?: string;
+            open?: boolean;
+        }): void;
+        /**
+         * Save all settings to the local storage
+         */
+        saveLocalStorages(): void;
+        /**
+         * Save the settings and apply changes
+         */
+        save(): void;
+        updateSettingsInProfiles(): void;
+        updateProfileButton(): void;
+        import(file: any): void;
+        /**
+         * Returns the value of the specified setting
+         */
+        get(id: string): SettingsValue;
+        openDialog(options?: {
+            search_term?: string;
+            profile?: string;
+        }): void;
+        showRestartMessage(settings?: Setting[]): void;
+        old: {};
+    };
+};
+declare global {
+    const settings: typeof globals.settings;
+    const Setting: typeof globals.Setting;
+    const SettingsProfile: typeof globals.SettingsProfile;
+    const Settings: typeof globals.Settings;
+}
 export {};

package/generated/interface/start_screen.d.ts

@@ -12,7 +12,7 @@ declare global {
      * @param {number} [data.graphic.aspect_ratio] Section aspect ratio
      * @param {string} [data.graphic.description] Markdown string
      * @param {string} [data.graphic.text_color]
-     * @param {Array.<{text: String, type: String, [list]: Array.String, [click]: Function}>} data.text
+     * @param {Array.<{text: String, {type}: [String], [list]: Array.String, {click}: [Function]}>} data.text
      * @param {'vertical'|'horizontal'} data.layout
      * @param {Array} data.features
      * @param {boolean} data.closable
@@ -35,21 +35,6 @@ declare global {
             description?: string;
             text_color?: string;
         };
-        text: Array<{
-            text: string;
-            type: string;
-            [list]: Array.String;
-            [click]: Function;
-        }>;
-        layout: "vertical" | "horizontal";
-        features: any[];
-        closable: boolean;
-        click: Function;
-        color: string;
-        text_color: string;
-        last: boolean;
-        insert_after: string;
-        insert_before: string;
     }): {
         delete(): void;
     };

package/generated/interface/themes.d.ts

@@ -93,4 +93,10 @@ declare global {
     }
     function loadThemes(): void;
 }
+declare const global: {
+    CustomTheme: typeof import("./themes").CustomTheme;
+};
+declare global {
+    const CustomTheme: typeof global.CustomTheme;
+}
 export {};

package/generated/io/format.d.ts

@@ -310,5 +310,13 @@ declare global {
         delete(): void;
     }
 }
-
+declare const global: {
+    ModelFormat: typeof import("./format").ModelFormat;
+    Formats: Record<string, ModelFormat>;
+};
+declare global {
+    const ModelFormat: typeof global.ModelFormat;
+    const Format: ModelFormat;
+    const Formats: Record<string, ModelFormat>;
+}
 export {};

package/generated/io/formats/bedrock_old.d.ts

@@ -1,5 +1,5 @@
 declare global {
-    function parseGeometry(data: any, args: any): any;
+    function parseGeometry(data: any, args: any): void;
 }
 
 export {};

package/generated/languages.d.ts

@@ -48,4 +48,49 @@ declare global {
         toString: () => string;
     };
 }
+declare const global: {
+    tl: (string: string, variables?: string | number | (string | number)[], default_value?: string) => string;
+    Language: {
+        /**
+         * Translation data for the current language
+         */
+        data: {};
+        /**
+         * Language code indicating the currently selected language
+         */
+        code: string;
+        options: {
+            en: string;
+            cz: string;
+            de: string;
+            es: string;
+            fr: string;
+            it: string;
+            ja: string;
+            ko: string;
+            nl: string;
+            pl: string;
+            pt: string;
+            pt_br: string;
+            ru: string;
+            sv: string;
+            tr: string;
+            uk: string;
+            vi: string;
+            zh: string;
+            zh_tw: string;
+        };
+        /**
+         * Add translations for custom translation strings
+         * @param language Two letter language code, e. G. 'en'
+         * @param strings Object listing the translation keys and values
+         */
+        addTranslations(language: string, strings: Record<string, string>): void;
+        toString: () => string;
+    };
+};
+declare global {
+    const Language: typeof global.Language;
+    const tl: typeof global.tl;
+}
 export {};

package/generated/lib/CanvasFrame.d.ts

@@ -14,5 +14,10 @@ declare global {
         isEmpty(): boolean;
     }
 }
-
+declare const global: {
+    CanvasFrame: typeof import("./CanvasFrame").CanvasFrame;
+};
+declare global {
+    const CanvasFrame: typeof global.CanvasFrame;
+}
 export {};

package/generated/main.d.ts

@@ -49,16 +49,16 @@ import "./validator";
 import "./outliner/outliner";
 import "./outliner/element_panel";
 import "./outliner/collections";
-import "./outliner/group";
-import "./outliner/mesh";
-import "./outliner/cube";
-import "./outliner/billboard";
-import "./outliner/texture_mesh";
-import "./outliner/armature";
-import "./outliner/armature_bone";
-import "./outliner/locator";
-import "./outliner/null_object";
-import "./outliner/spline_mesh";
+import "./outliner/types/group";
+import "./outliner/types/mesh";
+import "./outliner/types/cube";
+import "./outliner/types/billboard";
+import "./outliner/types/texture_mesh";
+import "./outliner/types/armature";
+import "./outliner/types/armature_bone";
+import "./outliner/types/locator";
+import "./outliner/types/null_object";
+import "./outliner/types/spline_mesh";
 import "./preview/preview";
 import "./preview/reference_images";
 import "./preview/screenshot";
@@ -116,5 +116,4 @@ import "./io/formats/skin";
 import "./io/formats/image";
 import "./boot_loader";
 import "./globals";
-import "./global_types";
 export {};

package/generated/misc.d.ts

@@ -38,17 +38,6 @@ declare global {
         let y: number;
     }
     const sort_collator: Intl.Collator;
-    namespace AutoBackup {
-        let db: IDBDatabase;
-        function initialize(): void;
-        function backupOpenProject(): Promise<void>;
-        function hasBackups(): Promise<any>;
-        function recoverAllBackups(): Promise<any>;
-        function removeBackup(uuid: any): Promise<any>;
-        function removeAllBackups(): Promise<any>;
-        let loop_timeout: any;
-        function backupProjectLoop(run_save?: boolean): void;
-    }
     namespace TickUpdates {
         function Run(): void;
     }

package/generated/modeling/mirror_modeling.d.ts

@@ -1,4 +1,4 @@
-import { Armature } from "../outliner/armature";
+import { Armature } from "../outliner/types/armature";
 declare global {
     const MirrorModeling: {
         initial_transformer_position: number;
@@ -37,4 +37,28 @@ declare global {
     }
     function symmetrizeArmature(armature: Armature, mesh: Mesh, affected_vkeys: Set<string>): void;
 }
+declare const global: {
+    MirrorModeling: {
+        initial_transformer_position: number;
+        outliner_snapshot: any;
+        isCentered(element: OutlinerElement): boolean;
+        createClone(original: OutlinerElement, undo_aspects: UndoAspects): any;
+        updateParentNodeCounterpart(node: OutlinerNode, original: OutlinerNode): void;
+        getEditSide(fallback?: number): number;
+        flipCoord(input: number): number;
+        getMirrorElement(element: OutlinerElement): OutlinerElement | false;
+        isParentTreeSymmetrical(element: OutlinerNode, { center }: {
+            center: any;
+        }): boolean;
+        isParentTreeOpposite(element1: OutlinerNode, element2: OutlinerNode): boolean;
+        insertElementIntoUndo(element: OutlinerElement, undo_aspects: UndoAspects, element_before_snapshot?: any): void;
+        insertGroupIntoUndo(group: Group, undo_aspects: UndoAspects, before_snapshop?: any): void;
+        element_types: Record<string, MirrorModelingElementTypeOptions>;
+        registerElementType(type_class: any, options: MirrorModelingElementTypeOptions): void;
+        cached_elements: {};
+    };
+};
+declare global {
+    const MirrorModeling: typeof global.MirrorModeling;
+}
 export {};

package/generated/modeling/scale.d.ts

@@ -1,13 +1,5 @@
 declare global {
-    namespace ModelScaler {
-        let dialog: import("../interface/dialog").Dialog;
-        let overflow: any;
-        function getScaleGroups(): Group[];
-        function scaleAll(save: any, size: any): void;
-        function cancel(): void;
-        function setPivot(mode: any): void;
-        function selectOverflow(): void;
-    }
+    const ModelScaler: any;
 }
 
 export {};

package/generated/modes.d.ts

@@ -58,4 +58,24 @@ declare global {
         mobileModeMenu(button: any, event: any): Menu;
     };
 }
+declare const global: {
+    Mode: typeof import("./modes").Mode;
+    Modes: {
+        readonly id: any;
+        vue: Vue | null;
+        selected: boolean | Mode;
+        previous_id: string;
+        options: Record<string, Mode>;
+        animate: boolean;
+        display: boolean;
+        edit: boolean;
+        paint: boolean;
+        pose: boolean;
+        mobileModeMenu(button: any, event: any): Menu;
+    };
+};
+declare global {
+    const Modes: typeof global.Modes;
+    const Mode: typeof global.Mode;
+}
 export {};

package/generated/outliner/abstract/face.d.ts

@@ -0,0 +1,40 @@
+import { Property } from "../../util/property";
+import { OutlinerElement } from "./outliner_element";
+declare global {
+    interface FaceOptions {
+        texture?: Texture | UUID | false;
+    }
+    abstract class Face {
+        texture: UUID | false | undefined;
+        element: OutlinerElement;
+        direction?: string;
+        uv: any;
+        /**
+         * Returns a 2D rectangle around the UV face
+         */
+        getBoundingRect(): any;
+        constructor(data: FaceOptions);
+        extend(data: FaceOptions): this;
+        getTexture(): Texture | undefined | null | false;
+        reset(): this;
+        /**
+         * Returns a save copy of the face, ready for serialization
+         */
+        getSaveCopy(): {
+            uv: any;
+            texture: any;
+        };
+        /**
+         * Get a copy for undo tracking
+         */
+        getUndoCopy(): Face;
+        static properties: Record<string, Property<any>>;
+    }
+}
+declare const global: {
+    Face: typeof import("./face").Face;
+};
+declare global {
+    const Face: typeof global.Face;
+}
+export {};

package/generated/outliner/abstract/outliner_element.d.ts

@@ -0,0 +1,42 @@
+import { Property } from "../../util/property";
+import { OutlinerNode } from "./outliner_node";
+type ElementTypeConstructor = {
+    new (...args: any[]): OutlinerElement;
+    init?(): void;
+    properties: Record<string, Property<any>>;
+    behavior: any;
+    selected: OutlinerElement[];
+};
+declare global {
+    interface OutlinerElementData {
+        name?: string;
+    }
+    abstract class OutlinerElement extends OutlinerNode {
+        allow_mirror_modeling?: boolean;
+        static animator?: BoneAnimator;
+        static isParent: false;
+        static all: OutlinerElement[];
+        static selected: OutlinerElement[];
+        constructor(data: OutlinerElementData, uuid?: string);
+        init(): this;
+        remove(): this;
+        showContextMenu(event: MouseEvent): this;
+        forSelected(fc: (element: OutlinerElement) => void, undo_tag?: string, selection_method?: 'all_selected' | 'all_in_group'): OutlinerElement[];
+        duplicate(): OutlinerElement;
+        select(event?: Event, is_outliner_click?: boolean): false | this;
+        clickSelect(event: any, outliner_click?: boolean): void;
+        markAsSelected(select_children?: boolean): this;
+        unselect(unselect_parent?: boolean): this;
+        getUndoCopy(): any;
+        getSaveCopy(): any;
+        static fromSave(obj: any, keep_uuid?: boolean): OutlinerElement;
+        static isTypePermitted(type: string): boolean;
+        /**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;
+        static types: Record<string, ElementTypeConstructor>;
+        static registerType(constructor: ElementTypeConstructor, id: string): void;
+    }
+}
+export {};

package/generated/outliner/abstract/outliner_node.d.ts

@@ -0,0 +1,96 @@
+import { Property } from "../../util/property";
+declare global {
+    abstract class OutlinerNode {
+        name: string;
+        uuid: UUID;
+        export: boolean;
+        locked: boolean;
+        parent: (OutlinerNode & OutlinerNodeParentTraits) | 'root';
+        selected: boolean;
+        old_name?: string;
+        children?: OutlinerNode[];
+        menu?: Menu;
+        type: string;
+        name_regex: ((element?: OutlinerNode) => string | boolean) | undefined;
+        static animator?: BoneAnimator;
+        static isParent: false;
+        static all: OutlinerNode[];
+        static selected: OutlinerNode[];
+        static preview_controller: NodePreviewController;
+        static properties: Record<string, Property<any>>;
+        static behavior: Record<string, any>;
+        constructor(uuid: UUID);
+        /**
+         * Initializes the node. This should always be called when creating nodes that will be used in the outliner.
+         */
+        init(): this;
+        extend?(data: any): void;
+        select(event?: Event, outliner_click?: boolean): false | this;
+        unselect(unselect_parent?: boolean): void;
+        clickSelect(event: MouseEvent, outliner_click?: boolean): void;
+        getTypeBehavior(flag: string): boolean | string | any;
+        sortInBefore(element?: OutlinerNode, index_modifier?: number): this;
+        addTo(target?: OutlinerNode | 'root', index?: number): this;
+        removeFromParent(): this;
+        getParentArray(): OutlinerNode[];
+        showContextMenu(event: any): this;
+        /**
+         * Unfolds the outliner and scrolls up or down if necessary to show the group or element.
+         */
+        showInOutliner(): void;
+        /**
+         * Updates the Vue node of the element. This is only necessary in some rare situations
+         */
+        updateElement(): this;
+        get mesh(): import("three").Object3D;
+        get scene_object(): THREE.Object3D;
+        getDepth(): number;
+        duplicate(): OutlinerNode;
+        /**
+         * Removes the node.
+         */
+        remove(remove_children?: boolean): void;
+        /**
+         * Marks the name of the group or element in the outliner for renaming.
+         */
+        rename(): this;
+        /**
+         * Saves the changed name of the element by creating an undo point and making the name unique if necessary.
+         */
+        saveName(save?: boolean): this;
+        sanitizeName(): string;
+        /**
+         * Create a unique name for the group or element by adding a number at the end or increasing it.
+         */
+        createUniqueName(others?: OutlinerNode[]): string | false;
+        isIconEnabled(toggle: any): any;
+        matchesFilter(search_term_lowercase: any): any;
+        /**
+         * Checks of the group or element is a child of `group`.
+         * @param max_levels The maximum number of generations that can be between the element and the group
+         */
+        isChildOf(node: OutlinerNode, max_levels: number): boolean;
+        get preview_controller(): NodePreviewController;
+        /**
+         * Mark the element as selected
+         */
+        markAsSelected(descendants?: boolean): void;
+        /**
+         * Displays the context menu of the element
+         * @param event Mouse event, determines where the context menu spawns.
+         */
+        showContexMenu(event: Event | HTMLElement): this;
+        getSaveCopy?(...args: any[]): Record<string, any>;
+        static addBehaviorOverride(override_options: {
+            condition: ConditionResolvable;
+            priority?: number;
+            behavior: Record<string, any>;
+        }): Deletable;
+        static behavior_overrides: any[];
+        static uuids: {
+            [uuid: UUID]: OutlinerNode;
+        };
+    }
+}
+
+export {};

package/generated/outliner/billboard.d.ts

@@ -74,5 +74,4 @@ declare global {
         buttons: OutlinerToggle[];
     }
 }
-
 export {};

package/generated/outliner/collections.d.ts

@@ -1,6 +1,6 @@
 import { Property } from "../util/property";
-import { OutlinerNode } from "./outliner";
 import { Menu } from "../interface/menu";
+import { OutlinerNode } from "./abstract/outliner_node";
 declare global {
     interface CollectionOptions {
         children?: string[];
@@ -81,5 +81,10 @@ declare global {
         static menu: Menu;
     }
 }
-
+declare const global: {
+    Collection: typeof import("./collections").Collection;
+};
+declare global {
+    const Collection: typeof global.Collection;
+}
 export {};

package/generated/outliner/spline_mesh.d.ts

@@ -215,5 +215,4 @@ declare global {
         buttons: OutlinerToggle[];
     }
 }
-
 export {};

package/generated/outliner/types/armature.d.ts

@@ -0,0 +1,59 @@
+import { OutlinerElement } from "../abstract/outliner_element";
+import { OutlinerNode } from "../abstract/outliner_node";
+import { ArmatureBone } from "./armature_bone";
+declare global {
+    interface ArmatureOptions {
+        name?: string;
+        export?: boolean;
+        locked?: boolean;
+        visibility?: boolean;
+    }
+    class Armature extends OutlinerElement {
+        children: (ArmatureBone | Mesh | NullObject)[];
+        isOpen: boolean;
+        visibility: boolean;
+        origin: ArrayVector3;
+        static preview_controller: NodePreviewController;
+        constructor(data?: ArmatureOptions, uuid?: UUID);
+        extend(object: ArmatureOptions): this;
+        getMesh(): import("three").Object3D;
+        init(): this;
+        markAsSelected(descendants?: boolean): this;
+        matchesSelection(): boolean;
+        openUp(): this;
+        getSaveCopy(): {
+            isOpen: boolean;
+            uuid: string;
+            type: string;
+            name: string;
+            children: string[];
+        };
+        getUndoCopy(): any;
+        getChildlessCopy(keep_uuid?: boolean): Armature;
+        forEachChild(cb: ((element: OutlinerElement) => void), type?: typeof OutlinerNode, forSelf?: boolean): void;
+        getAllBones(): ArmatureBone[];
+        calculateVertexDeformation(mesh: Mesh): Record<string, ArrayVector3>;
+        static behavior: {
+            unique_name: boolean;
+            movable: boolean;
+            rotatable: boolean;
+            parent: boolean;
+            child_types: string[];
+        };
+        title: string;
+        type: string;
+        icon: string;
+        name_regex: () => false | "a-zA-Z0-9_";
+        buttons: OutlinerToggle[];
+        menu: Menu;
+        static all: Armature[];
+        static selected: Armature[];
+    }
+}
+declare const global: {
+    Armature: typeof import("./armature").Armature;
+};
+declare global {
+    const Armature: typeof global.Armature;
+}
+export {};

package/generated/outliner/types/armature_bone.d.ts

@@ -0,0 +1,90 @@
+import { Armature } from "./armature";
+import { OutlinerElement } from "../abstract/outliner_element";
+declare global {
+    interface ArmatureBoneOptions {
+        name?: string;
+        export?: boolean;
+        locked?: boolean;
+        visibility?: boolean;
+        origin?: ArrayVector3;
+        rotation?: ArrayVector3;
+        vertex_weights?: Record<string, number>;
+        length?: number;
+        width?: number;
+        connected?: boolean;
+        color?: number;
+    }
+    class ArmatureBone extends OutlinerElement {
+        children: ArmatureBone[];
+        isOpen: boolean;
+        visibility: boolean;
+        origin: ArrayVector3;
+        rotation: ArrayVector3;
+        vertex_weights: Record<string, number>;
+        length: number;
+        width: number;
+        connected: boolean;
+        color: number;
+        old_size?: number | ArrayVector3;
+        static preview_controller: NodePreviewController;
+        constructor(data?: ArmatureBoneOptions, uuid?: UUID);
+        get position(): ArrayVector3;
+        extend(object: ArmatureBoneOptions): this;
+        getArmature(): Armature;
+        getVertexWeight(mesh: Mesh, vkey: string): number;
+        setVertexWeight(mesh: Mesh, vkey: string, weight?: number): void;
+        init(): this;
+        select(event?: Event, isOutlinerClick?: boolean): false | this;
+        markAsSelected(descendants: boolean): this;
+        matchesSelection(): boolean;
+        openUp(): this;
+        transferOrigin(origin: ArrayVector3): this;
+        getWorldCenter(): THREE.Vector3;
+        flip(axis: number, center: number): this;
+        size(): ArrayVector3;
+        size(axis: axisLetter): number;
+        getSize(axis: any): number;
+        resize(move_value: number | ((input: number) => number), axis_number?: axisNumber, invert?: boolean): void;
+        setColor(index: any): this;
+        getSaveCopy(): {
+            isOpen: boolean;
+            uuid: string;
+            type: string;
+            name: string;
+            children: string[];
+        };
+        getUndoCopy(): any;
+        getChildlessCopy(keep_uuid?: boolean): ArmatureBone;
+        forEachChild(cb: ((element: ArmatureBone) => void), type?: any, forSelf?: boolean): void;
+        static behavior: {
+            unique_name: boolean;
+            parent: boolean;
+            movable: boolean;
+            rotatable: boolean;
+            resizable: boolean;
+            child_types: string[];
+            parent_types: string[];
+            select_children: string;
+            hide_in_screenshot: boolean;
+            marker_color: boolean;
+        };
+        static all: ArmatureBone[];
+        static selected: ArmatureBone[];
+        title: string;
+        type: string;
+        icon: string;
+        name_regex: () => false | "a-zA-Z0-9_";
+        buttons: OutlinerToggle[];
+        menu: Menu;
+    }
+    function getAllArmatureBones(): any[];
+}
+declare const global: {
+    ArmatureBone: typeof import("./armature_bone").ArmatureBone;
+    getAllArmatureBones: typeof import("./armature_bone").getAllArmatureBones;
+};
+declare global {
+    const ArmatureBone: typeof global.ArmatureBone;
+    const getAllArmatureBones: typeof global.getAllArmatureBones;
+}
+export {};