minerender 2.0.0-alpha.8 → 2.1.0-alpha.0

package/dist/node/index.d.ts

@@ -0,0 +1,1607 @@
+import * as three from 'three';
+import { Vector3, PixelFormat, BoxGeometry, Material, Mesh, Euler, Vector2, BufferAttribute, Float32BufferAttribute, Object3D, Box3, InstancedMesh, PerspectiveCamera, OrthographicCamera, Matrix4, Scene, Texture, Camera, WebGLRenderer, EventDispatcher, Raycaster, Intersection, CanvasTexture, BufferGeometry as BufferGeometry$1, InterleavedBufferAttribute, TrianglesDrawModes, Line, Points, MOUSE, TOUCH } from 'three';
+import * as nodeCanvas from 'canvas';
+import { ImageData as ImageData$1, CanvasRenderingContext2D } from 'canvas';
+import { AxiosResponse, AxiosRequestConfig } from 'axios';
+import { Buffer as Buffer$1 } from 'buffer';
+import { NBT } from 'prismarine-nbt';
+import { ZipReader } from '@zip.js/zip.js';
+import { AsyncLoadingCache, SimpleCache } from '@inventivetalent/loading-cache';
+import { BufferGeometry } from 'three/src/core/BufferGeometry';
+import { Material as Material$1 } from 'three/src/materials/Material';
+import Stats from 'stats.js';
+import { EffectComposer } from 'postprocessing';
+import { LocalStorage } from 'node-persist';
+
+interface AnimatorFunction {
+    (): void;
+}
+
+declare enum Axis {
+    X = "X",
+    Y = "y",
+    Z = "z"
+}
+declare const AXES: Axis[];
+declare function axisToVec3(axis: Axis): Vector3;
+
+declare enum CubeFace {
+    EAST = "east",// px
+    WEST = "west",// nx
+    UP = "up",// py
+    DOWN = "down",// ny
+    SOUTH = "south",// pz
+    NORTH = "north"
+}
+declare enum CubeFaceIndex {
+    EAST = 0,
+    WEST = 1,
+    UP = 2,
+    DOWN = 3,
+    SOUTH = 4,
+    NORTH = 5
+}
+declare const CUBE_FACES: CubeFace[];
+
+interface Disposable {
+    dispose(): void;
+}
+declare function isDisposable(obj: any): obj is Disposable;
+
+type CompatImage = HTMLImageElement | nodeCanvas.Image;
+type CompatCanvas = HTMLCanvasElement | nodeCanvas.Canvas;
+declare function createImage(width?: number, height?: number): CompatImage;
+declare function createCanvas(width: number, height: number): CompatCanvas;
+
+/**
+ * Key/value store that survives a page reload or process restart.
+ *
+ * The concrete backing store is supplied by the active {@link EnvProvider} - `localforage`
+ * (IndexedDB) in the browser, `node-persist` (disk) under Node - so this file itself stays
+ * free of any platform-specific import.
+ */
+declare abstract class PersistentCache<B = unknown> {
+    readonly backing: B;
+    /** Bump to invalidate every persisted entry. */
+    static readonly VERSION = 1;
+    static open(name: string): PersistentCache;
+    protected constructor(backing: B);
+    abstract get<T>(key: string): Promise<T>;
+    getOrLoad<T>(key: string, loader: (key: string) => Promise<T>): Promise<T>;
+    abstract put<T>(key: string, value: T): Promise<T>;
+    abstract delete<T>(key: string): Promise<void>;
+    abstract clear(): Promise<void>;
+    abstract length(): Promise<number>;
+    abstract keys(): Promise<string[]>;
+    abstract forEach<T>(callback: (v: T, k: string) => void): Promise<void>;
+}
+
+/**
+ * Dimensions probed from raw, still-encoded image bytes.
+ * Mirrors the subset of `image-size`'s result that MineRender actually uses.
+ */
+interface ImageSizeInfo {
+    width?: number;
+    height?: number;
+    type?: string;
+}
+/**
+ * Everything MineRender needs from the platform it is running on.
+ *
+ * This is the seam between the browser and Node builds: core code only ever talks to the
+ * registered provider, so nothing outside of `src/env/node/` may reference a Node-only module
+ * (`canvas`, `node-persist`, `image-size`, `fs`, …). Keeping that rule is what allows the browser
+ * bundle to be built without Node polyfills.
+ */
+interface EnvProvider {
+    readonly name: string;
+    createCanvas(width: number, height: number): CompatCanvas;
+    createImage(width?: number, height?: number): CompatImage;
+    /** Read width/height out of encoded image bytes without fully decoding them. */
+    imageSize(data: Uint8Array): ImageSizeInfo;
+    openCache(name: string, version: number): PersistentCache;
+}
+/**
+ * Registry holding the active {@link EnvProvider}.
+ *
+ * The `minerender` package entries register one for you — importing the library through its
+ * `exports` map gets you the browser provider in bundlers and the Node provider under Node.
+ * Only call {@link Env.register} directly if you are embedding MineRender in an exotic host.
+ */
+declare class Env {
+    private static _provider;
+    static register(provider: EnvProvider): void;
+    static get registered(): boolean;
+    static get provider(): EnvProvider;
+}
+
+interface ExtractableImageData {
+    readonly data: CanvasImageData;
+    readonly width: number;
+    readonly height: number;
+}
+
+type CacheKey = string;
+interface RawImageKey {
+    src: string;
+}
+declare function serializeImageKey(key: RawImageKey): string;
+interface BoxGeometryKey {
+    width: number;
+    height: number;
+    depth: number;
+    uv?: number[];
+}
+declare function serializeBoxGeometryKey(key: BoxGeometryKey): string;
+interface TextureKey extends RawImageKey {
+    format?: PixelFormat;
+    rotation?: number;
+}
+declare function serializeTextureKey(key: TextureKey): string;
+interface MaterialKey {
+    texture: TextureKey;
+    transparent?: boolean;
+}
+declare function serializeMaterialKey(key: MaterialKey): string;
+interface MeshKey {
+    geometry: BoxGeometryKey;
+    material: MaterialKey;
+}
+declare function serializeMeshKey(key: MeshKey): string;
+
+declare class Geometries {
+    static createBox(key: BoxGeometryKey): BoxGeometry;
+    static getBox(key: BoxGeometryKey): BoxGeometry;
+}
+
+interface Serializable {
+    serialize(): string;
+}
+
+type AssetType = "models" | "textures" | "blockstates" | string;
+declare class BasicAssetKey implements Serializable {
+    readonly namespace: string;
+    readonly path: string;
+    constructor(key: BasicAssetKey);
+    constructor(namespace: string, path: string);
+    toNamespacedString(): string;
+    toString(): string;
+    serialize(): string;
+}
+declare class AssetKey extends BasicAssetKey {
+    readonly namespace: string;
+    readonly path: string;
+    assetType?: AssetType | undefined;
+    type?: string | undefined;
+    rootType: "assets" | "data" | string;
+    extension: ".json" | ".png" | string;
+    root?: string | undefined;
+    constructor(namespace: string, path: string, assetType?: AssetType | undefined, type?: string | undefined, rootType?: "assets" | "data" | string, extension?: ".json" | ".png" | string, root?: string | undefined);
+    static parse(assetType: AssetType, str: string, origin?: AssetKey): AssetKey;
+    toString(): string;
+    getFullPath(): string;
+    toNamespacedString(): string;
+    serialize(): string;
+}
+declare function isBasicAssetKey(obj: any): obj is BasicAssetKey;
+declare function isAssetKey(obj: any): obj is AssetKey;
+
+interface BasicMinecraftAsset {
+    key?: BasicAssetKey;
+}
+interface MinecraftAsset extends BasicMinecraftAsset {
+    key?: AssetKey;
+}
+
+interface ListAsset extends MinecraftAsset {
+    directories: string[];
+    files: string[];
+}
+
+declare class Materials {
+    private static readonly MISSING_TEXTURE_SRC;
+    static get MISSING_TEXTURE(): Material;
+    static createImage(key: MaterialKey): Material;
+    static createBasicCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean): Material;
+    static createShadedCanvasMaterial(canvas: HTMLCanvasElement, transparent?: boolean, shade?: boolean): Material;
+    static getImage(key: MaterialKey): Material;
+    static needsUpdate(mat: Material): void;
+}
+
+declare class Meshes {
+    static createBox(key: MeshKey): Mesh;
+    static getBox(key: MeshKey): Mesh;
+}
+
+interface ElementFace {
+    uv: QuadArray;
+    mappedUv?: QuadArray;
+    texture: string;
+    cullface?: string;
+    rotation?: number;
+    tintindex?: number;
+}
+
+interface FromTo {
+    from: TripleArray;
+    to: TripleArray;
+}
+interface ModelElement extends FromTo {
+    rotation?: ElementRotation;
+    shade?: boolean;
+    faces: ModelFaces;
+    mappedUv?: number[];
+}
+type ModelFaces = Partial<Record<CubeFace, Partial<ElementFace>>>;
+interface ElementRotation {
+    origin: TripleArray;
+    axis: Axis;
+    angle: number;
+    rescale: boolean;
+}
+
+declare enum DisplayPosition {
+    THIRDPERSON_RIGHTHAND = "thirdperson_righthand",
+    THIRDPERSON_LEFTHAND = "thirdperson_lefthand",
+    FIRSTPERSON_RIGHTHAND = "firstperson_righthand",
+    FIRSTPERSON_LEFTHAND = "firstperson_lefthand",
+    GUI = "gui",
+    HEAD = "head",
+    GROUND = "ground",
+    FIXED = "fixed"
+}
+declare const DISPLAY_POSITIONS: DisplayPosition[];
+
+declare enum GuiLight {
+    FRONT = "front",
+    SIDE = "side"
+}
+
+declare class WrappedImage {
+    readonly dta: ExtractableImageData;
+    constructor(dta: ExtractableImageData);
+    get data(): ImageData$1;
+    get dataArray(): Uint8ClampedArray;
+    get width(): number;
+    get height(): number;
+    get hasTransparency(): boolean;
+    get animated(): boolean;
+    get frameWidth(): number;
+    get frameHeight(): number;
+    get frameCount(): number;
+    getFrameY(frame: number): number;
+    getSectionData(sx: number, sy: number, sw: number, sh: number): ImageData$1;
+    getPixel(x: number, y: number): Uint8ClampedArray;
+    getFrameSectionData(frame: number): ImageData$1;
+}
+
+interface ImageInfo {
+    src?: string;
+    width: number;
+    height: number;
+    type?: string;
+    data: Buffer$1;
+}
+declare class ImageLoader {
+    protected static _createImage(): CompatImage;
+    static loadAsync(src: string): Promise<CompatImage>;
+    static loadElement(src: string, onload?: () => void, onerr?: (err: Error) => void): CompatImage;
+    static loadData(src: string): Promise<ImageData>;
+    static loadCanvasData(src: string): Promise<ExtractableImageData>;
+    static infoToCanvasData(info: ImageInfo): Promise<ExtractableImageData>;
+    static infoToData(info: ImageInfo): Promise<ImageData>;
+    static getData(src: string): Promise<ImageData>;
+    static getCanvasData(src: string): Promise<ExtractableImageData>;
+    static processResponse(response: Partial<AxiosResponse>): Promise<ImageInfo>;
+    static loadInfo(src: string): Promise<ImageInfo>;
+    static getInfo(src: string): Promise<ImageInfo>;
+    static loadWrapped(src: string): Promise<WrappedImage>;
+    static getWrapped(src: string): Promise<WrappedImage>;
+}
+
+declare const ITEM_GENERATED = "item/generated";
+declare const BUILTIN_GENERATED = "builtin/generated";
+declare const BUILTIN_ENTITY = "builtin/entity";
+declare const DEFAULT_ELEMENTS: ModelElement[];
+interface Model extends MinecraftAsset {
+    textures?: IModelTextures;
+    parent?: string;
+    display?: ModelDisplay;
+    elements?: ModelElement[];
+    hierarchy?: string[];
+}
+interface BlockModel extends Model {
+    textures?: BlockModelTextures;
+    ambientocclusion?: boolean;
+}
+interface ItemModel extends Model {
+    textures?: ItemModelTextures;
+    gui_light?: GuiLight;
+}
+interface TextureAsset extends MinecraftAsset, ImageInfo {
+}
+interface ModelDisplay {
+    position?: DisplayPosition;
+    translation?: TripleArray;
+    rotation?: TripleArray;
+    scale?: TripleArray;
+}
+interface IModelTextures {
+    [variable: string]: string;
+}
+interface BlockModelTextures extends IModelTextures {
+    particle: string;
+}
+interface ItemModelTextures extends BlockModelTextures {
+}
+type DoubleArray<T = number> = [T, T];
+type TripleArray<T = number> = [T, T, T];
+type QuadArray<T = number> = [T, T, T, T];
+declare function isDoubleArray(obj: any): obj is DoubleArray;
+declare function isTripleArray(obj: any): obj is TripleArray;
+declare function isQuadArray(obj: any): obj is QuadArray;
+
+/**
+ *          down  up
+ *  east    north    west    south
+ *
+ *  bottom-left to top-right
+ *  [bl, br, tl, tr]
+ */
+declare class MinecraftCubeTexture {
+    readonly u: number;
+    readonly v: number;
+    readonly width: number;
+    readonly height: number;
+    constructor(u: number, v: number, width: number, height: number);
+    protected mapW(x: number): number;
+    protected mapH(x: number): number;
+    getUvEast(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getUvWest(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getUvUp(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getUvDown(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getUvSouth(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getUvNorth(w: number, h: number, l: number): QuadArray<DoubleArray>;
+    getFaceUv(face: CubeFace, w: number, h: number, l: number): QuadArray<DoubleArray>;
+    toUvArray(w: number, h: number, l: number): number[];
+}
+
+interface MinecraftTextureMeta extends MinecraftAsset {
+    animation: AnimationMeta;
+}
+interface AnimationMeta {
+    interpolate: boolean;
+    width: number;
+    height: number;
+    frametime: number;
+    frames: Array<number | AnimationFrame>;
+}
+interface AnimationFrame {
+    index: number;
+    time: number;
+}
+
+declare class SceneStats {
+    objectCount: number;
+    sceneObjectCount: number;
+    instanceCount: number;
+}
+
+interface TickerFunction {
+    (): void;
+}
+/**
+ * Shared 20-per-second tick loop, used for things like animated texture frames.
+ *
+ * The timers are started lazily by {@link Ticker.add} and unref'd where the platform supports it -
+ * importing MineRender must never on its own keep a Node process alive.
+ */
+declare class Ticker {
+    static readonly TPS = 20;
+    private static counter;
+    private static readonly _tickers;
+    private static interval;
+    private static oneSecondTicksTracker;
+    private static fiveSecondTicksTracker;
+    private static oneSecondTps;
+    private static oneSecondTicks;
+    private static fiveSecondTps;
+    private static fiveSecondTicks;
+    private static schedule;
+    static start(): void;
+    static stop(): void;
+    static add(tick: TickerFunction): number;
+    static remove(c?: number): void;
+    static get tickers(): Map<number, TickerFunction>;
+    static get tpsOneSecond(): number;
+    static get tpsFiveSeconds(): number;
+    static dispose(): void;
+}
+
+declare const TintColors: never[];
+
+interface Transformable {
+    setPositionRotationScale(position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    setPosition(position: Vector3): void;
+    getPosition(): Vector3;
+    setRotation(rotation: Euler): void;
+    getRotation(): Euler;
+    setScale(scale: Vector3): void;
+    getScale(): Vector3;
+}
+declare function isTransformable(obj: any): obj is Transformable;
+
+declare const changeEvent: {
+    type: string;
+};
+type Maybe<T> = T | undefined;
+declare function md5(str: string): string;
+declare function sha1(str: string): string;
+declare function sha256(str: string): string;
+declare function sha512(str: string): string;
+declare function base64encode(str: string): string;
+declare function base64decode(str: string): string;
+declare function toRadians(degrees: number): number;
+declare function toDegrees(radians: number): number;
+declare function sleep(timeout: number): Promise<void>;
+declare function clampRotationDegrees(deg: number): number;
+declare function isVector3(obj: any): obj is Vector3;
+type DeepPartial<T> = {
+    [P in keyof T]?: DeepPartial<T[P]>;
+};
+
+declare class ModelTextures {
+    private static _persistentMetaCache;
+    private static get PERSISTENT_META_CACHE();
+    static get(key: AssetKey): Promise<Maybe<ExtractableImageData>>;
+    static preload(key: AssetKey): Promise<Maybe<TextureAsset>>;
+    static getMeta(key: AssetKey): Promise<Maybe<MinecraftTextureMeta>>;
+    static clearCache(): Promise<void>;
+}
+
+declare class CanvasImage implements Disposable {
+    readonly canvas: CompatCanvas;
+    readonly context: CanvasRenderingContext2D;
+    constructor(width: number, height: number);
+    constructor(data: ImageData$1);
+    get width(): number;
+    set width(width: number);
+    get height(): number;
+    set height(height: number);
+    get dataUrl(): string;
+    toDataURL(): string;
+    getData(sx?: number, sy?: number, sw?: number, sh?: number): ImageData$1;
+    putData(data: ImageData$1, dx?: number, dy?: number, dirtyX?: number, dirtyY?: number, dirtyWidth?: number, dirtyHeight?: number): void;
+    test(): void;
+    dispose(): void;
+}
+
+declare class TextureAtlas implements Disposable {
+    readonly model: Model;
+    readonly image: CanvasImage;
+    readonly sizes: {
+        [texture: string]: DoubleArray;
+    };
+    readonly positions: {
+        [texture: string]: DoubleArray;
+    };
+    readonly hasAnimation: boolean;
+    readonly animatorFunctions: {
+        [p: string]: AnimatorFunction;
+    };
+    readonly hasTransparency: boolean;
+    ticker?: number;
+    constructor(model: Model, image: CanvasImage, sizes: {
+        [texture: string]: DoubleArray;
+    }, positions: {
+        [texture: string]: DoubleArray;
+    }, hasAnimation: boolean, animatorFunctions: {
+        [p: string]: AnimatorFunction;
+    }, hasTransparency: boolean);
+    getData(texture: string): ImageData$1;
+    dispose(): void;
+}
+
+declare const DEFAULT_UV: QuadArray;
+declare class UVMapper {
+    protected static makeUv(uvCoord: number, originalTextureSize: number, actualTextureSize: number): number;
+    protected static makeUvCoords([originalTextureWidth, originalTextureHeight]: DoubleArray, [actualTextureWidth, actualTextureHeight]: DoubleArray, [x1, y1, x2, y2]: QuadArray): QuadArray;
+    static rotateSingleUv([u, v]: DoubleArray, [px, py]: DoubleArray, radians: number): DoubleArray;
+    static addCubeFaceUvToArray(array: number[], faceIndex: number, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray, originalCoords: QuadArray): void;
+    static setCubeFaceUvInArray(array: number[], faceIndex: number, [u1, v1, u2, v2]: QuadArray): void;
+    static setFaceUvInArrayV(array: number[], faceIndex: number, uvs: QuadArray<Vector2>): void;
+    static setFaceUvInArray(array: number[], faceIndex: number, uvs: QuadArray<DoubleArray>): void;
+    static setCubeFaceUvAttribute(attributes: BufferAttribute, faceIndex: number, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray, originalCoords: QuadArray): void;
+    static setCubeFaceUvInAttribute(attributes: BufferAttribute, faceIndex: number, [u1, v1, u2, v2]: QuadArray): void;
+    static setCubeUvs(geometry: BoxGeometry, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray, faces: ModelFaces): void;
+    static facesToUvArray(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): number[];
+    static facesToUv(faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): Float32BufferAttribute;
+    static getAtlas(model: Model): Promise<Maybe<TextureAtlas>>;
+    static fillMissingTextureKeys<T>(textures: ModelTextures, target: {
+        [k: string]: T;
+    }): {
+        [k: string]: T;
+    };
+    protected static getFallbackUv(element: ModelElement, faceName: CubeFace): QuadArray;
+    protected static expandAndRotateMcUvs([u1, v1, u2, v2]: QuadArray, rotation: number | undefined, actualWidth: number, actualHeight: number): QuadArray<Vector2>;
+    static createAtlas(originalModel: Model): Promise<Maybe<TextureAtlas>>;
+}
+declare class MinecraftFaceUV {
+    readonly uv: QuadArray;
+    readonly rotation: number;
+    constructor(uv?: QuadArray, rotation?: number);
+    getU(index: number): number;
+    getV(index: number): number;
+    protected getShiftedIndex(index: number): number;
+    protected getReverseIndex(index: number): number;
+}
+
+/**
+ * Releases every long-lived timer MineRender holds, so a Node process can exit.
+ *
+ * Both `@inventivetalent/loading-cache` (cache expiry) and `jobqu` (request queue draining) use
+ * self-rescheduling timers that are not unref'd, which keeps the event loop alive for as long as
+ * the library is loaded. Browsers don't care, but anything headless - a render server, a CLI, a
+ * test run - has to call this when it's done.
+ *
+ * The library stays usable afterwards; the caches and queues simply start over.
+ */
+declare function shutdown(): void;
+
+declare class BatchedExecutor {
+    readonly interval: number;
+    readonly batch: number;
+    private readonly queue;
+    private readonly task;
+    constructor(interval?: number, batch?: number);
+    submit(task: Task): void;
+    private run;
+    private runNext;
+}
+type Task = () => any | Promise<any>;
+
+declare function prefix(prefix?: string): string;
+
+interface ModelPart {
+    textureWidth: number;
+    textureHeight: number;
+    textureOffsetU: number;
+    textureOffsetV: number;
+    pivotX: number;
+    pivotY: number;
+    pivotZ: number;
+    pitch: number;
+    yaw: number;
+    roll: number;
+    mirror: boolean;
+    cubes: Cube[];
+    children: ModelPart[];
+}
+interface Cube {
+    minX: number;
+    minY: number;
+    minZ: number;
+    maxX: number;
+    maxY: number;
+    maxZ: number;
+}
+
+declare function applyElementRotation(rotation: ElementRotation, geometry: BufferGeometry): void;
+declare function applyModelPartRotation(modelPart: ModelPart, geometry: BufferGeometry): void;
+declare function applyGenericRotation(axis: Axis, rotation: number, obj: Object3D): void;
+declare function addBox3WireframeToObject(box: Box3, obj: Object3D, color?: number, w?: number): void;
+declare function addWireframeToObject(obj: Object3D, color?: number, w?: number): void;
+declare function addWireframeToMesh(geo: BufferGeometry, mesh: Mesh, color?: number, w?: number): void;
+
+declare function captureException(e: any, ...extra: any[]): void;
+declare function timingStart(marker: string): void;
+declare function timingEnd(marker: string): void;
+
+declare function isObject3D(obj: any): obj is Object3D;
+declare function isMesh(obj: any): obj is Mesh;
+declare function isInstancedMesh(obj: any): obj is InstancedMesh;
+declare function isPerspectiveCamera(obj: any): obj is PerspectiveCamera;
+declare function isOrthographicCamera(obj: any): obj is OrthographicCamera;
+
+declare enum AssetParser {
+    MODEL = "model",
+    BLOCKSTATE = "blockstate",
+    META = "meta",
+    NBT = "nbt",
+    IMAGE = "image",
+    LIST = "list",
+    JSON = "json"
+}
+
+declare abstract class AssetSource {
+    protected constructor();
+    abstract get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>>;
+}
+
+declare class AssetLoader {
+    static ROOT: string;
+    private static _SOURCES;
+    static addSource(key: string, source: AssetSource, override?: boolean): void;
+    static removeSource(key: string): Maybe<AssetSource>;
+    static getAll<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<T[]>;
+    static get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>>;
+}
+
+interface BlockState extends MinecraftAsset {
+    variants?: BlockStateVariants;
+    multipart?: BlockStateMultipart[];
+}
+type BlockStateVariants = {
+    [key: string]: BlockStateVariant | BlockStateVariant[];
+};
+interface BlockStateVariant {
+    model?: string;
+    y?: number;
+    x?: number;
+    uvlock?: boolean;
+}
+interface BlockStateMultipart {
+    when?: MultipartCondition | {
+        OR: MultipartCondition[];
+    };
+    apply?: BlockStateVariant;
+}
+interface MultipartCondition {
+    [key: string]: string;
+}
+
+declare const DEFAULT_ROOT = "https://cdn.mcasset.cloud/file/minecraft-assets/1.17.1";
+declare const DEFAULT_NAMESPACE = "minecraft";
+declare class Assets {
+    /**
+     * @deprecated
+     */
+    static parseAssetKey(assetType: AssetType, str: string, origin?: AssetKey): AssetKey;
+    static getModel(key: AssetKey): Promise<Maybe<Model>>;
+    static getBlockState(key: AssetKey): Promise<Maybe<BlockState>>;
+}
+
+type BlockStatePropertyValue = string | boolean | number;
+interface BlockStateProperty {
+    default: BlockStatePropertyValue;
+    type: "boolean" | "int" | "enum";
+    valueType: "boolean" | "int" | string;
+    values: BlockStatePropertyValue[];
+}
+type BlockStatePropertyDefaults = {
+    [key: string]: BlockStateProperty;
+};
+type BlockStateProperties = {
+    [key: string]: string;
+};
+
+declare class BlockStates {
+    private static _persistentCache;
+    private static get PERSISTENT_CACHE();
+    static getList(): Promise<string[]>;
+    static getDefaultStates(): Promise<Maybe<DefaultBlockStates>>;
+    static getDefaultState(key: AssetKey): Promise<Maybe<BlockStatePropertyDefaults>>;
+    static get(key: AssetKey): Promise<Maybe<BlockState>>;
+    static getAll(keys: AssetKey[] | Iterable<AssetKey>): Promise<Maybe<BlockState>[]>;
+    static clearCache(): Promise<void>;
+}
+declare class DefaultBlockStates implements MinecraftAsset {
+    [k: string]: BlockStatePropertyDefaults;
+}
+
+interface EntityModel extends BasicMinecraftAsset {
+    parts?: {
+        [p: string]: ModelPart;
+    };
+}
+
+declare class Entities {
+    static getBlockEntityModels(): Promise<Maybe<BlockEntityModels>>;
+    static getEntityModels(): Promise<Maybe<EntityModels>>;
+    static getBlockList(): Promise<string[]>;
+    static getEntityList(): Promise<string[]>;
+    static getBlock(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<Maybe<EntityModel>>;
+    static getEntity(modelKey: BasicAssetKey, textureKey?: BasicAssetKey): Promise<Maybe<EntityModel>>;
+}
+declare class EntityModels implements MinecraftAsset {
+    [k: string]: any;
+}
+declare class BlockEntityModels implements MinecraftAsset {
+    [k: string]: any;
+}
+
+declare class Models {
+    private static _persistentCache;
+    private static get PERSISTENT_CACHE();
+    static getItemList(): Promise<string[]>;
+    static loadAndMerge(key: AssetKey): Promise<Maybe<Model>>;
+    static getRaw(key: AssetKey): Promise<Maybe<Model>>;
+    static getMerged(key: AssetKey): Promise<Maybe<Model>>;
+    static get(key: AssetKey): Promise<Maybe<Model>>;
+    static clearCache(): Promise<void>;
+}
+
+declare class ModelGenerator {
+    static readonly ITEM_LAYERS: string[];
+    static generateItemModel(imageData: ImageData$1, layer: string): ModelElement[];
+}
+
+declare class ModelMerger {
+    static mergeWithParents(model: Model): Promise<Model>;
+    protected static collectAllParents(model: Model): Promise<Model[]>;
+}
+
+interface Block {
+    type: string;
+    properties?: BlockStateProperties;
+    nbt?: any;
+}
+
+interface Instanceable {
+    nextInstance(): InstanceReference<SceneObject>;
+    getMatrixAt(index: number, matrix?: Matrix4): Matrix4;
+    setMatrixAt(index: number, matrix: Matrix4): void;
+    setPositionRotationScaleAt(index: number, position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    setPositionAt(index: number, position: Vector3): void;
+    getPositionAt(index: number, vector?: Vector3): Vector3;
+    setRotationAt(index: number, rotation: Euler): void;
+    getRotationAt(index: number, euler?: Euler): Euler;
+    setScaleAt(index: number, scale: Vector3): void;
+    getScaleAt(index: number, vector?: Vector3): Vector3;
+}
+declare function isInstanceable(obj: any): obj is Instanceable;
+
+declare class InstanceReference<T extends Instanceable> implements Transformable {
+    readonly instanceable: T;
+    readonly index: number;
+    readonly isInstanceReference: true;
+    constructor(instanceable: T, index: number);
+    nextInstance(): InstanceReference<SceneObject>;
+    getMatrix(matrix?: Matrix4): Matrix4;
+    setMatrix(matrix: Matrix4): void;
+    setPositionRotationScale(position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    setPosition(position: Vector3): void;
+    getPosition(): Vector3;
+    setRotation(rotation: Euler): void;
+    getRotation(): Euler;
+    setScale(scale: Vector3): void;
+    getScale(): Vector3;
+}
+declare function isInstanceReference(obj: any): obj is InstanceReference<any>;
+
+interface SceneObjectOptions {
+    wireframe: boolean;
+    mergeMeshes: boolean;
+    instanceMeshes: boolean;
+    maxInstanceCount: number;
+}
+
+declare class ModelObject extends SceneObject {
+    readonly originalModel: Model;
+    readonly isModelObject: true;
+    static readonly DEFAULT_OPTIONS: ModelObjectOptions;
+    readonly options: ModelObjectOptions;
+    private atlas?;
+    blockParent: Maybe<BlockObject>;
+    private meshesCreated;
+    constructor(originalModel: Model, options?: Partial<ModelObjectOptions>);
+    init(): Promise<void>;
+    dispose(): void;
+    get textureAtlas(): Maybe<TextureAtlas>;
+    protected loadTextures(): Promise<void>;
+    protected createMeshes(force?: boolean): void;
+    protected applyTextures(): void;
+}
+interface ModelObjectOptions extends SceneObjectOptions {
+}
+declare function isModelObject(obj: any): obj is ModelObject;
+
+declare class InstanceManager {
+    readonly isInstanceManager: true;
+    protected readonly instanceCache: {
+        [key: string]: Promise<InstanceReference<SceneObject>>;
+    };
+    constructor();
+    get<T extends SceneObject>(key: string): Promise<Maybe<InstanceReference<T>>>;
+    getOrCreate<T extends SceneObject>(key: string, supplier: () => T | Promise<T>): Promise<InstanceReference<T>>;
+    reset(): void;
+}
+declare function isInstanceManager(obj: any): obj is InstanceManager;
+
+declare enum SkinPart {
+    HEAD = "head",
+    BODY = "body",
+    RIGHT_ARM = "rightArm",
+    LEFT_ARM = "leftArm",
+    RIGHT_LEG = "rightLeg",
+    LEFT_LEG = "leftLeg",
+    HAT = "hat",
+    JACKET = "jacket",
+    RIGHT_SLEEVE = "rightSleeve",
+    LEFT_SLEEVE = "leftSleeve",
+    RIGHT_TROUSERS = "rightTrousers",
+    LEFT_TROUSERS = "leftTrousers",
+    CAPE = "cape"
+}
+declare const SKIN_PARTS: SkinPart[];
+
+declare class SkinObject extends SceneObject {
+    readonly options: SkinObjectOptions;
+    private slim;
+    private legacy;
+    private skinTextureSrc?;
+    private skinTextureWidth;
+    private skinTextureHeight;
+    private capeTextureSrc?;
+    constructor(options?: DeepPartial<SkinObjectOptions>);
+    init(): Promise<void>;
+    protected removeMeshes(): void;
+    protected createMeshes(): void;
+    setSkinTexture(src: string): void;
+    setSlim(slim: boolean): void;
+    setLegacy(legacy: boolean): void;
+    protected getBoxGeometry(part: SkinPart): BoxGeometry;
+}
+interface SkinObjectOptions extends SceneObjectOptions {
+}
+
+declare class EntityObject extends SceneObject {
+    readonly entity: EntityModel;
+    readonly isEntityObject: true;
+    static readonly DEFAULT_OPTIONS: EntityObjectOptions;
+    readonly options: EntityObjectOptions;
+    private imageData?;
+    private meshesCreated;
+    constructor(entity: EntityModel, options?: Partial<EntityObjectOptions>);
+    init(): Promise<void>;
+    dispose(): void;
+    protected loadTextures(): Promise<void>;
+    protected createMeshes(force?: boolean): void;
+    protected applyTextures(): Promise<void>;
+}
+interface EntityObjectOptions extends SceneObjectOptions {
+}
+declare function isEntityObject(obj: any): obj is EntityObject;
+
+declare class MineRenderScene extends Scene {
+    readonly isMineRenderScene: true;
+    static readonly DEFAULT_OPTIONS: MineRenderSceneOptions;
+    readonly options: MineRenderSceneOptions;
+    readonly stats: SceneStats;
+    protected readonly instanceManager: InstanceManager;
+    dirty: boolean;
+    constructor(options?: DeepPartial<MineRenderSceneOptions>);
+    add(...object: any[]): this;
+    remove(...object: any[]): this;
+    initAndAdd(...object: SceneObject[]): Promise<this>;
+    addSceneObject<A extends BasicMinecraftAsset, T extends SceneObject, O extends SceneObjectOptions>(asset: A, objectSupplier: () => T | Promise<T>, _options?: Partial<O>, parent?: Object3D): Promise<T | InstanceReference<T>>;
+    addModel(model: Model, options?: Partial<ModelObjectOptions>, parent?: Object3D): Promise<ModelObject | InstanceReference<ModelObject>>;
+    addBlock(blockState: BlockState, options?: Partial<BlockObjectOptions>, parent?: Object3D): Promise<BlockObject | InstanceReference<BlockObject>>;
+    addSkin(skin?: string, options?: Partial<SkinObjectOptions>, parent?: Object3D): Promise<SkinObject>;
+    addEntity(entity: EntityModel, options?: Partial<EntityObjectOptions>, parent?: Object3D): Promise<EntityObject | InstanceReference<EntityObject>>;
+}
+interface MineRenderSceneOptions {
+}
+declare function isMineRenderScene(obj: any): obj is MineRenderScene;
+
+declare class SceneObject extends Object3D implements Disposable, Instanceable, Transformable {
+    readonly isSceneObject: true;
+    static readonly DEFAULT_OPTIONS: SceneObjectOptions;
+    readonly options: SceneObjectOptions;
+    private _scene;
+    private materialCallbacks;
+    protected _isInstanced: boolean;
+    _instanceCounter: number;
+    constructor(options?: Partial<SceneObjectOptions>);
+    set scene(scene: MineRenderScene);
+    get scene(): MineRenderScene;
+    init(): Promise<void>;
+    notifyDirty(): void;
+    protected createAndAddGroup(name?: string, x?: number, y?: number, z?: number, offsetAxis?: Axis, offset?: number): Object3D;
+    protected createGroup(name?: string, x?: number, y?: number, z?: number, offsetAxis?: Axis, offset?: number): Object3D;
+    /**
+     * Get a group by its name
+     */
+    getGroupByName(name: string): Maybe<Object3D>;
+    /**
+     * Toggle visibility of a group
+     * @param name name of the group
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    toggleGroupVisibility(name: string, visible?: boolean): boolean;
+    protected addOrReplaceMesh(mesh: Mesh, parent: Object3D, name?: string): void;
+    protected createAndAddMesh(name?: string, group?: Object3D, geometry?: BufferGeometry, material?: Material$1 | Material$1[], offsetAxis?: Axis, offset?: number): Mesh;
+    protected createMesh(name?: string, geometry?: BufferGeometry, material?: Material$1 | Material$1[], offsetAxis?: Axis, offset?: number): Mesh;
+    protected createInstancedMesh(name: Maybe<string>, geometry: BufferGeometry, material: Material$1 | Material$1[], count: number): InstancedMesh;
+    /**
+     * Get a mesh by its name
+     */
+    getMeshByName(name: string): Maybe<Mesh>;
+    /**
+     * Toggle visibility of a mesh
+     * @param name name of the mesh
+     * @param visible set the visibility directly, if not set toggles it
+     */
+    toggleMeshVisibility(name: string, visible?: boolean): boolean;
+    iterateAllMeshes(cb: (mesh: Mesh) => void): void;
+    protected _getBoxGeometryFromDimensions([width, height, depth]: TripleArray, faces: ModelFaces, originalTextureSize: DoubleArray, actualTextureSize: DoubleArray): BoxGeometry;
+    protected _getBoxGeometryFromElement(element: ModelElement): BoxGeometry;
+    protected _getBoxGeometryForDimensionsAndUv(width: number, height: number, depth: number, uv: number[]): BoxGeometry;
+    get isInstanced(): boolean;
+    get instanceCounter(): number;
+    protected constructInstanceReference(i: number): InstanceReference<SceneObject>;
+    nextInstance(): InstanceReference<SceneObject>;
+    getMatrixAt(index: number, matrix?: Matrix4): Matrix4;
+    setMatrixAt(index: number, matrix: Matrix4): void;
+    setPositionRotationScaleAt(index: number, position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    setPositionAt(index: number, position: Vector3): void;
+    getPositionAt(index: number, vector?: Vector3): Vector3;
+    setRotationAt(index: number, rotation: Euler): void;
+    getRotationAt(index: number, euler?: Euler): Euler;
+    setScaleAt(index: number, scale: Vector3): void;
+    getScaleAt(index: number, vector?: Vector3): Vector3;
+    setPositionRotationScale(position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    setPosition(position: Vector3): void;
+    getPosition(): Vector3;
+    setRotation(rotation: Euler): void;
+    getRotation(): Euler;
+    setScale(scale: Vector3): void;
+    getScale(): Vector3;
+    protected toggleObjectVisibility(object?: Object3D, visible?: boolean): boolean;
+    dispose(): void;
+    disposeAndRemoveAllChildren(): void;
+    removeFromScene(): void;
+}
+declare function isSceneObject(obj: any): obj is SceneObject;
+
+declare class BlockObject extends SceneObject {
+    readonly blockState: BlockState;
+    readonly isBlockObject: true;
+    static readonly DEFAULT_OPTIONS: BlockObjectOptions;
+    readonly options: BlockObjectOptions;
+    private _previousState;
+    private _state;
+    private _variant;
+    private _instanceState;
+    private _instanceVariant;
+    private _instanceModel;
+    private _variants;
+    private _models;
+    constructor(blockState: BlockState, options?: Partial<BlockObjectOptions>);
+    init(): Promise<void>;
+    dispose(): void;
+    removeFromScene(): void;
+    get state(): {
+        [key: string]: string;
+    };
+    nextInstance(): InstanceReference<SceneObject>;
+    protected mapStateToVariant(state: BlockStateProperties): Promise<BlockStateVariant[]>;
+    recreateModels(): Promise<void>;
+    protected getSingleVariant(variants: BlockStateVariant | BlockStateVariant[]): BlockStateVariant;
+    protected createAVariant(variants: BlockStateVariant | BlockStateVariant[], instanceInfo: Matrix4[]): Promise<void>;
+    protected createVariant(variant: BlockStateVariant): Promise<ModelObject | InstanceReference<ModelObject>>;
+    resetState(): Promise<void>;
+    setState(string: string): any;
+    setState(state: BlockStateProperties): any;
+    setState(key: string, value: string): any;
+    protected _setState(stringOrKeyOrState: string | BlockStateProperties, value?: string): void;
+    setPositionRotationScaleAt(index: number, position?: Vector3, rotation?: Euler, scale?: Vector3): void;
+    getMatrixAt(index: number, matrix?: Matrix4): Matrix4;
+    setMatrixAt(index: number, matrix: Matrix4): void;
+    setPosition(position: Vector3): void;
+}
+interface BlockObjectOptions extends ModelObjectOptions {
+    applyDefaultState: boolean;
+}
+declare function isBlockObject(obj: any): obj is BlockObject;
+
+interface MultiBlockStructure {
+    readonly size: TripleArray;
+    readonly blocks: MultiBlockBlock[];
+}
+interface MultiBlockBlock extends Block {
+    position: TripleArray;
+}
+
+declare class SchematicParser {
+    static parse(): Promise<MultiBlockStructure>;
+}
+
+declare class StructureParser {
+    static parse(_nbt: NBT, paletteIndex?: number): Promise<MultiBlockStructure>;
+}
+interface StructureNBT {
+    DataVersion: {
+        type: "int";
+        value: number;
+    };
+    size: {
+        type: "list";
+        value: {
+            type: "int";
+            value: TripleArray;
+        };
+    };
+    palette?: Palette;
+    palettes?: Palette[];
+    blocks: {
+        type: "list";
+        value: {
+            type: "compound";
+            value: BlockEntry[];
+        };
+    };
+    entities: {};
+}
+interface Palette {
+    type: "list";
+    value: {
+        type: "compound";
+        value: PaletteEntry[];
+    };
+}
+interface PaletteEntry {
+    Name: {
+        type: "string";
+        value: string;
+    };
+    Properties: {
+        type: "compound";
+        value: {
+            [property: string]: PalettePropertyValue;
+        };
+    };
+}
+interface PalettePropertyValue {
+    type: string;
+    value: string;
+}
+interface BlockEntry {
+    pos: {
+        type: "list";
+        value: {
+            type: "int";
+            value: TripleArray;
+        };
+    };
+    state: {
+        type: "int";
+        value: number;
+    };
+    nbt: {
+        type: "compound";
+        value: any;
+    };
+}
+
+declare class NBTHelper {
+    static fromBuffer(buffer: Buffer): Promise<NBTAsset>;
+}
+interface NBTAsset extends MinecraftAsset, NBT {
+}
+
+interface ResponseParser<T extends MinecraftAsset> {
+    config(request: AxiosRequestConfig): any;
+    parse(response: AxiosResponse): Maybe<T> | Promise<Maybe<T>>;
+}
+
+declare class HostedAssetSource extends AssetSource {
+    static readonly MODEL: ResponseParser<Model>;
+    static readonly BLOCKSTATE: ResponseParser<BlockState>;
+    static readonly META: ResponseParser<MinecraftTextureMeta>;
+    static readonly NBT: ResponseParser<NBTAsset>;
+    static readonly IMAGE: ResponseParser<TextureAsset>;
+    static readonly LIST: ResponseParser<ListAsset>;
+    static readonly JSON: ResponseParser<any>;
+    static readonly PARSER_MAP: Map<AssetParser, ResponseParser<any>>;
+    loadOrRetryWithDefaults<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>>;
+    protected load<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>>;
+    assetBasePath(key: AssetKey): string;
+    private readonly _root;
+    private readonly _options;
+    constructor(root: string, options?: Partial<HostedAssetSourceOptions>);
+    get root(): string;
+    get options(): HostedAssetSourceOptions;
+    get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser): Promise<Maybe<T>>;
+}
+interface HostedAssetSourceOptions {
+    retryDefaults: boolean;
+}
+
+interface ArchiveEntry {
+    filename: string;
+    directory: boolean;
+    getData(): Promise<Blob>;
+}
+
+interface ArchiveProxy {
+    getEntries(): Promise<ArchiveEntry[]>;
+}
+
+declare class ArchiveAssetSource extends AssetSource implements ArchiveProxy {
+    readonly _archiveProxy: ArchiveProxy;
+    constructor(archiveProxy: ArchiveProxy);
+    static blob(blob: Blob): ArchiveAssetSource;
+    getEntries(): Promise<ArchiveEntry[]>;
+    getEntry(path: string): Promise<Maybe<ArchiveEntry>>;
+    get<T extends MinecraftAsset>(key: AssetKey, parser: AssetParser | string): Promise<Maybe<T>>;
+    protected load<T extends MinecraftAsset>(key: AssetKey, parser: ResponseParser<T>): Promise<Maybe<T>>;
+    assetBasePath(key: AssetKey): string;
+}
+
+declare class BrowserArchiveProxy implements ArchiveProxy {
+    readonly _blob: Blob;
+    readonly _reader: ZipReader<Blob>;
+    constructor(blob: Blob);
+    getEntries(): Promise<ArchiveEntry[]>;
+}
+
+interface BedrockEntityDescription {
+    identifier: string;
+    materials: {
+        [k: string]: string;
+    };
+    textures: {
+        [k: string]: string;
+    };
+    geometry: {
+        [k: string]: string;
+    };
+    scripts?: any;
+    animations: {
+        [k: string]: string;
+    };
+    animation_controllers?: any;
+    render_controllers: any;
+    enable_attachables?: boolean;
+}
+
+interface BedrockEntityFile {
+    format_version: string;
+    "minecraft:client_entity": {
+        "description": BedrockEntityDescription;
+    };
+}
+
+interface BedrockGeometry {
+    visible_bounds_width: number;
+    visible_bounds_height: number;
+    visible_bounds_offset: TripleArray;
+    texturewidth: number;
+    textureheight: number;
+    bones: BedrockBone[];
+}
+interface BedrockBone {
+    name: string;
+    parent?: string;
+    reset?: boolean;
+    pivot?: TripleArray;
+    cubes?: BedrockCube[];
+    rotation?: TripleArray;
+    neverRender?: boolean;
+    locators?: {
+        [k: string]: TripleArray;
+    };
+}
+interface BedrockCube {
+    origin: TripleArray;
+    size: TripleArray;
+    uv?: DoubleArray;
+    inflate?: number;
+}
+
+interface BedrockGeometryFile {
+    format_version: string;
+    [key: string]: BedrockGeometry | any;
+}
+
+declare class Caching {
+    static readonly rawImageCache: AsyncLoadingCache<CacheKey, ImageInfo>;
+    static readonly imageDataCache: AsyncLoadingCache<CacheKey, ImageData>;
+    static readonly canvasImageDataCache: AsyncLoadingCache<CacheKey, ExtractableImageData>;
+    static readonly wrappedImageCache: AsyncLoadingCache<CacheKey, WrappedImage>;
+    static readonly boxGeometryCache: SimpleCache<CacheKey, BoxGeometry>;
+    static readonly textureCache: SimpleCache<CacheKey, Texture>;
+    static readonly materialCache: SimpleCache<CacheKey, Material>;
+    static readonly boxMeshCache: SimpleCache<CacheKey, Mesh>;
+    static readonly textureAssetCache: AsyncLoadingCache<CacheKey, TextureAsset>;
+    static readonly textureMetaCache: AsyncLoadingCache<CacheKey, MinecraftTextureMeta>;
+    static readonly rawModelCache: AsyncLoadingCache<CacheKey, Model>;
+    static readonly mergedModelCache: AsyncLoadingCache<CacheKey, Model>;
+    static readonly modelTextureAtlasCache: AsyncLoadingCache<CacheKey, TextureAtlas>;
+    static readonly blockStateCache: AsyncLoadingCache<CacheKey, BlockState>;
+    /** Every cache above, so clear()/end() can never fall out of sync with the field list again. */
+    private static get all();
+    static clear(): void;
+    /**
+     * Clears every cache and stops its expiry timer.
+     *
+     * loading-cache reschedules that timer indefinitely, so a Node process will not exit until
+     * this is called - see {@link shutdown}.
+     */
+    static end(): void;
+    static get cacheSizes(): {};
+}
+
+declare class MineRenderError extends Error {
+    constructor(msg: any);
+    get name(): string;
+}
+
+declare class GuiObject extends SceneObject {
+}
+interface GuiObjectOptions extends SceneObjectOptions {
+}
+
+declare class Renderer {
+    static readonly DEFAULT_OPTIONS: RendererOptions;
+    readonly options: RendererOptions;
+    protected _element?: HTMLElement;
+    protected _scene: MineRenderScene;
+    protected _camera: Camera;
+    protected _renderer: WebGLRenderer;
+    protected _composer: EffectComposer;
+    protected _stats?: Stats;
+    protected _dirty: boolean;
+    protected _animationLoop: any;
+    protected _fpsTimer: any;
+    protected _animationTimer?: NodeJS.Timeout;
+    protected _animationFrame?: number;
+    protected _resizeListener?: () => void;
+    constructor(options?: DeepPartial<RendererOptions>);
+    protected createScene(): MineRenderScene;
+    protected createCamera(): Camera;
+    protected createRenderer(): WebGLRenderer;
+    protected createComposer(): EffectComposer;
+    init(): void;
+    get element(): Maybe<HTMLElement>;
+    appendTo(element: HTMLElement): void;
+    /**
+     * Register an EventDispatcher which may update the scene or renderer in order to redraw the scene
+     */
+    registerEventDispatcher(dispatcher: EventDispatcher, changeEvent?: string): void;
+    resize(width: number, height: number): void;
+    get dirty(): boolean;
+    set dirty(dirty: boolean);
+    start(): void;
+    stop(): void;
+    private animate;
+    toImage(): string;
+    protected get attachedToBody(): boolean;
+    protected get viewWidth(): number;
+    protected get viewHeight(): number;
+    get scene(): MineRenderScene;
+    get camera(): Camera;
+    get renderer(): WebGLRenderer;
+    get composer(): EffectComposer;
+}
+interface RendererOptions {
+    camera: CameraOptions;
+    render: RenderOptions;
+    composer: ComposerOptions;
+    debug: DebugOptions;
+}
+interface CameraOptions {
+    type: "perspective" | "orthographic";
+    near: number;
+    far: number;
+    perspective: {
+        aspect: undefined | number;
+        fov: number;
+    };
+    orthographic: {
+        left: undefined | number;
+        right: undefined | number;
+        top: undefined | number;
+        bottom: undefined | number;
+    };
+    position: Vector3 | TripleArray;
+    lookingAt: Vector3 | TripleArray;
+}
+interface RenderOptions {
+    fpsLimit: number;
+    stats: boolean;
+    antialias: boolean;
+    shade: boolean;
+    autoResize: boolean;
+    renderAlways: boolean;
+}
+interface ComposerOptions {
+    enabled: boolean;
+}
+interface DebugOptions {
+    grid: boolean;
+    axes: boolean;
+}
+
+declare class SceneInspector {
+    readonly renderer: Renderer;
+    readonly objectInfoContainer: HTMLDivElement;
+    readonly objectControlsContainer: HTMLDivElement;
+    protected readonly raycaster: Raycaster;
+    private readonly mouse;
+    private selectedObject?;
+    constructor(renderer: Renderer);
+    protected init(): void;
+    findMeshChildren(from: Object3D, out?: Mesh[]): Mesh<three.BufferGeometry, three.Material | three.Material[]>[];
+    onClick(event: any): void;
+    appendTo(el: HTMLElement): void;
+    protected handleRaycasterObjects(intersections: Intersection[]): void;
+    selectObject(targetObject: Object3D, targetIntersection?: Intersection): void;
+    protected redraw(targetObject: Object3D, targetIntersection?: Intersection): void;
+    protected addControls(object: Object3D, intersection?: Intersection): void;
+    protected addInfoLine(name: string, id: string, value: any): HTMLElement;
+    protected addObjectControls(target: Object3D, intersection: Maybe<Intersection>, container: HTMLElement): void;
+    protected buttonControl(name: string, id: string, click: () => void): HTMLElement;
+    protected selectControl(name: string, id: string, options: string[], change: (v: string) => void): HTMLElement;
+    protected toggleControl(name: string, id: string, val: boolean, change: (v: boolean) => void): HTMLElement;
+    protected rangeControl(name: string, id: string, min: number, max: number, val: number, step: number, change: (v: number) => void): HTMLElement;
+    protected separator(name?: string): HTMLElement;
+}
+
+declare class SceneStatsDisplay {
+    readonly renderer: Renderer;
+    readonly statsContainer: HTMLDivElement;
+    private readonly lines;
+    constructor(renderer: Renderer);
+    protected init(): void;
+    appendTo(el: HTMLElement): void;
+    add(line?: StatLine): void;
+}
+declare class StatLine {
+    readonly key: string;
+    readonly shortName: string;
+    readonly longName: string;
+    readonly valueProvider: () => number;
+    readonly wrapper: HTMLSpanElement;
+    readonly element: HTMLSpanElement;
+    value: number;
+    constructor(key: string, shortName: string, longName: string, valueProvider: () => number);
+    update(): void;
+}
+
+declare class Requests {
+    private static axiosInstance;
+    private static mcAssetInstance;
+    private static genericQueue;
+    private static mcAssetRequestQueue;
+    static genericRequest(request: AxiosRequestConfig): Promise<AxiosResponse>;
+    static mcAssetRequest(request: AxiosRequestConfig): Promise<AxiosResponse>;
+    private static shouldRetry;
+    static setMcAssetRoot(root: string): void;
+    static get queueSizes(): {
+        generic: number;
+        mcAsset: number;
+    };
+    /**
+     * Stops both queue timers. jobqu reschedules itself indefinitely, so a Node process will not
+     * exit until this is called - see {@link shutdown}.
+     */
+    static end(): void;
+}
+
+type SkinGeometries = Record<SkinPart, TripleArray>;
+declare const classicSkinGeometries: SkinGeometries;
+declare const slimSkinGeometries: SkinGeometries;
+
+type SkinTextureCoordinates = Record<SkinPart, ModelFaces>;
+declare const classicSkinTextureCoordinates: Readonly<SkinTextureCoordinates>;
+declare const slimSkinTextureCoordinates: Readonly<SkinTextureCoordinates>;
+
+declare class Skins {
+    static fromUuidOrUsername(uuidOrUsername: string): Promise<Maybe<string>>;
+    static fromUuid(uuid: string): Promise<Maybe<string>>;
+    static fromUsername(username: string): Promise<Maybe<string>>;
+    static fromMineSkin(mineskinId: string): Promise<Maybe<string>>;
+    static capeFromUuidOrUsername(uuidOrUsername: string): Promise<Maybe<string>>;
+    static capeFromUuid(uuid: string): Promise<Maybe<string>>;
+    static capeFromUsername(username: string): Promise<Maybe<string>>;
+    static capeFromCapesDev(uuid: string, capeType?: string): Promise<Maybe<string>>;
+    private static usernameToUuid;
+    private static usernameToUuidSkinProxy;
+    private static usernameToUuidMineTools;
+    private static getProfileFromMinetools;
+    private static getMineSkin;
+    private static getCapesDev;
+    private static getCrafatarSkinUrl;
+    private static getCrafatarCapeUrl;
+    private static getMcHeadsSkinUrl;
+    private static getMineSkinPlayerSkinUrl;
+    private static getSkinProxySkinUrl;
+    private static getSkinProxyCapeUrl;
+}
+
+declare class TextureLoader {
+    protected static createTexture(): Texture;
+    static loadInBackground(src: string, format?: PixelFormat, rotation?: number): Texture;
+    static load(src: string, format?: PixelFormat, rotation?: number): Texture;
+}
+
+declare class Textures {
+    static initTextureProps<T extends Texture>(texture: T): T;
+    static createImage(key: TextureKey): Texture;
+    static createAsset(key: AssetKey): Texture;
+    static createCanvasTexture(canvas: HTMLCanvasElement): CanvasTexture;
+    static getImage(key: TextureKey): Texture;
+}
+
+declare function mergeBufferGeometries(geometries: BufferGeometry$1[], useGroups?: boolean): BufferGeometry$1;
+declare function mergeBufferAttributes(attributes: BufferAttribute[]): BufferAttribute;
+declare function interleaveAttributes(attributes: BufferAttribute[]): InterleavedBufferAttribute;
+declare function estimateBytesUsed(geometry: BufferGeometry$1): number;
+declare function mergeVertices(geometry: BufferGeometry$1, tolerance?: number): BufferGeometry$1;
+declare function toTrianglesDrawMode(geometry: BufferGeometry$1, drawMode: TrianglesDrawModes): BufferGeometry$1;
+declare function computeMorphedAttributes(object: Mesh | Line | Points): object;
+
+declare class OrbitControls {
+    constructor(object: Camera, domElement?: HTMLElement);
+
+    object: Camera;
+    domElement: HTMLElement | HTMLDocument;
+
+    // API
+    enabled: boolean;
+    target: Vector3;
+
+    // deprecated
+    center: Vector3;
+
+    minDistance: number;
+    maxDistance: number;
+
+    minZoom: number;
+    maxZoom: number;
+
+    minPolarAngle: number;
+    maxPolarAngle: number;
+
+    minAzimuthAngle: number;
+    maxAzimuthAngle: number;
+
+    enableDamping: boolean;
+    dampingFactor: number;
+
+    enableZoom: boolean;
+    zoomSpeed: number;
+
+    enableRotate: boolean;
+    rotateSpeed: number;
+
+    enablePan: boolean;
+    panSpeed: number;
+    screenSpacePanning: boolean;
+    keyPanSpeed: number;
+
+    autoRotate: boolean;
+    autoRotateSpeed: number;
+
+    enableKeys: boolean;
+    keys: { LEFT: string; UP: string; RIGHT: string; BOTTOM: string };
+    mouseButtons: { LEFT: MOUSE; MIDDLE: MOUSE; RIGHT: MOUSE };
+    touches: { ONE: TOUCH; TWO: TOUCH };
+
+    update(): boolean;
+
+    listenToKeyEvents(domElement: HTMLElement): void;
+
+    saveState(): void;
+
+    reset(): void;
+
+    dispose(): void;
+
+    getPolarAngle(): number;
+
+    getAzimuthalAngle(): number;
+
+    getDistance(): number;
+
+    // EventDispatcher mixins
+    addEventListener(type: string, listener: (event: any) => void): void;
+
+    hasEventListener(type: string, listener: (event: any) => void): boolean;
+
+    removeEventListener(type: string, listener: (event: any) => void): void;
+
+    dispatchEvent(event: { type: string; target: any }): void;
+}
+
+declare class MapControls extends OrbitControls {
+    constructor(object: Camera, domElement?: HTMLElement);
+}
+
+interface BlockInfo {
+    block: Block;
+    object: BlockObject;
+}
+
+declare class Chunk {
+    readonly scene: MineRenderScene;
+    readonly x: number;
+    readonly y: number;
+    readonly z: number;
+    private readonly _blocks;
+    private readonly _anchor;
+    constructor(scene: MineRenderScene, x: number, y: number, z: number);
+    getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
+    getBlockAt(pos: Vector3): Maybe<BlockInfo>;
+    getBlockAt(pos: TripleArray): Maybe<BlockInfo>;
+    /**
+     * Set block at a _world_ position
+     */
+    setBlockAt(x: number, y: number, z: number, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: Vector3, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: TripleArray, block: Maybe<Block>): Promise<Maybe<BlockInfo>>;
+    /**
+     * Set block at a _chunk_ position (0-16)
+     */
+    setBlockInChunkAt(pos: Vector3, block?: Block, worldPos?: Vector3): Promise<Maybe<BlockInfo>>;
+    clear(): Promise<void>;
+    dispose(): Promise<void>;
+    static chunkPosToBlockIndex(pos: Vector3): number;
+    worldPosToChunkPos(pos: Vector3): Vector3;
+    chunkPosToWorldPos(pos: Vector3): Vector3;
+}
+
+declare class MineRenderWorld {
+    readonly scene: MineRenderScene;
+    private _size;
+    private _blockSize;
+    private readonly _chunks;
+    constructor(scene: MineRenderScene);
+    getBlockAt(x: number, y: number, z: number): Maybe<BlockInfo>;
+    getBlockAt(pos: Vector3): Maybe<BlockInfo>;
+    getBlockAt(pos: TripleArray): Maybe<BlockInfo>;
+    setBlockAt(x: number, y: number, z: number, block: Block): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: Vector3, block: Block): Promise<Maybe<BlockInfo>>;
+    setBlockAt(pos: TripleArray, block: Block): Promise<Maybe<BlockInfo>>;
+    placeMultiBlock(multiblock: MultiBlockStructure, useBatches?: boolean, executor?: BatchedExecutor): Promise<void>;
+    clear(): Promise<void>;
+    private getOrCreateChunkAt;
+    getChunkAt(pos: Vector3): Maybe<Chunk>;
+    static worldToScenePosition(pos: Vector3): Vector3;
+    static sceneToWorldPosition(pos: Vector3): Vector3;
+    worldPosToChunkIndex(pos: Vector3): number;
+    worldPosToChunkKey(pos: Vector3): string;
+    validatePosBounds(pos: Vector3): void;
+}
+
+/**
+ * {@link EnvProvider} for headless Node.
+ *
+ * This is the only place in the library allowed to reach for Node-only modules. Nothing here may
+ * be imported from `src/index.ts` - it is reachable exclusively through the `src/index.node.ts`
+ * entry, which is what keeps `canvas` and friends out of the browser bundle.
+ *
+ * `canvas` is an optional dependency: browser-only consumers never install its native binary.
+ * Importing this module without it will fail, which is intended - rasterisation under Node needs it.
+ */
+declare class NodeEnv implements EnvProvider {
+    readonly name = "node";
+    createCanvas(width: number, height: number): CompatCanvas;
+    createImage(width?: number, height?: number): CompatImage;
+    imageSize(data: Uint8Array): ImageSizeInfo;
+    openCache(name: string, version: number): PersistentCache;
+}
+declare function registerNodeEnv(): NodeEnv;
+
+/**
+ * {@link PersistentCache} backed by node-persist (one directory of JSON files per cache).
+ *
+ * node-persist requires an explicit `init()` before any read or write; that is done lazily on
+ * first access so that merely constructing the cache stays free of filesystem side effects.
+ */
+declare class NodeCache extends PersistentCache<LocalStorage> {
+    private initialized;
+    constructor(backing: LocalStorage);
+    private ready;
+    get<T>(key: string): Promise<T>;
+    put<T>(key: string, value: T): Promise<T>;
+    delete<T>(key: string): Promise<void>;
+    clear(): Promise<void>;
+    length(): Promise<number>;
+    keys(): Promise<string[]>;
+    forEach<T>(callback: (v: T, k: string) => void): Promise<void>;
+}
+
+export { AXES, type AnimationFrame, type AnimationMeta, type AnimatorFunction, ArchiveAssetSource, type ArchiveEntry, type ArchiveProxy, AssetKey, AssetLoader, AssetParser, AssetSource, type AssetType, Assets, Axis, BUILTIN_ENTITY, BUILTIN_GENERATED, BasicAssetKey, type BasicMinecraftAsset, BatchedExecutor, type BedrockBone, type BedrockCube, type BedrockEntityDescription, type BedrockEntityFile, type BedrockGeometry, type BedrockGeometryFile, type Block, BlockEntityModels, type BlockInfo, type BlockModel, type BlockModelTextures, BlockObject, type BlockObjectOptions, type BlockState, type BlockStateMultipart, type BlockStateProperties, type BlockStateProperty, type BlockStatePropertyDefaults, type BlockStatePropertyValue, type BlockStateVariant, type BlockStateVariants, BlockStates, type BoxGeometryKey, BrowserArchiveProxy, CUBE_FACES, type CacheKey, Caching, type CameraOptions, CanvasImage, Chunk, type CompatCanvas, type CompatImage, type ComposerOptions, type Cube, CubeFace, CubeFaceIndex, DEFAULT_ELEMENTS, DEFAULT_NAMESPACE, DEFAULT_ROOT, DEFAULT_UV, DISPLAY_POSITIONS, type DebugOptions, type DeepPartial, DefaultBlockStates, DisplayPosition, type Disposable, type DoubleArray, type ElementFace, type ElementRotation, Entities, type EntityModel, EntityModels, EntityObject, type EntityObjectOptions, Env, type EnvProvider, type ExtractableImageData, type FromTo, Geometries, GuiLight, GuiObject, type GuiObjectOptions, HostedAssetSource, type IModelTextures, ITEM_GENERATED, type ImageInfo, ImageLoader, type ImageSizeInfo, InstanceManager, InstanceReference, type Instanceable, type ItemModel, type ItemModelTextures, type ListAsset, MapControls, type MaterialKey, Materials, type Maybe, type MeshKey, Meshes, MineRenderError, MineRenderScene, type MineRenderSceneOptions, MineRenderWorld, type MinecraftAsset, MinecraftCubeTexture, MinecraftFaceUV, type MinecraftTextureMeta, type Model, type ModelDisplay, type ModelElement, type ModelFaces, ModelGenerator, ModelMerger, ModelObject, type ModelObjectOptions, type ModelPart, ModelTextures, Models, type MultiBlockBlock, type MultiBlockStructure, type MultipartCondition, type NBTAsset, NBTHelper, NodeCache, NodeEnv, OrbitControls, PersistentCache, type QuadArray, type RawImageKey, type RenderOptions, Renderer, type RendererOptions, Requests, type ResponseParser, SKIN_PARTS, SceneInspector, SceneObject, type SceneObjectOptions, SceneStats, SceneStatsDisplay, SchematicParser, type Serializable, type SkinGeometries, SkinObject, type SkinObjectOptions, SkinPart, type SkinTextureCoordinates, Skins, type StructureNBT, StructureParser, type TextureAsset, TextureAtlas, type TextureKey, TextureLoader, Textures, Ticker, type TickerFunction, TintColors, type Transformable, type TripleArray, UVMapper, WrappedImage, addBox3WireframeToObject, addWireframeToMesh, addWireframeToObject, applyElementRotation, applyGenericRotation, applyModelPartRotation, axisToVec3, base64decode, base64encode, captureException, changeEvent, clampRotationDegrees, classicSkinGeometries, classicSkinTextureCoordinates, computeMorphedAttributes, createCanvas, createImage, estimateBytesUsed, interleaveAttributes, isAssetKey, isBasicAssetKey, isBlockObject, isDisposable, isDoubleArray, isEntityObject, isInstanceManager, isInstanceReference, isInstanceable, isInstancedMesh, isMesh, isMineRenderScene, isModelObject, isObject3D, isOrthographicCamera, isPerspectiveCamera, isQuadArray, isSceneObject, isTransformable, isTripleArray, isVector3, md5, mergeBufferAttributes, mergeBufferGeometries, mergeVertices, prefix, registerNodeEnv, serializeBoxGeometryKey, serializeImageKey, serializeMaterialKey, serializeMeshKey, serializeTextureKey, sha1, sha256, sha512, shutdown, sleep, slimSkinGeometries, slimSkinTextureCoordinates, timingEnd, timingStart, toDegrees, toRadians, toTrianglesDrawMode };