@types/three 0.171.0 → 0.173.0

three/src/renderers/common/nodes/Nodes.d.ts

@@ -33,20 +33,37 @@ interface ComputeNodeData {
 }
 interface SceneData {
     background?: Color | Texture | CubeTexture | undefined;
-    backgroundNode?: Node | undefined;
+    backgroundNode?: ShaderNodeObject<Node> | undefined;
     fog?: Fog | FogExp2 | undefined;
-    fogNode?: Node | undefined;
+    fogNode?: ShaderNodeObject<Node> | undefined;
     environment?: Texture | undefined;
-    environmentNode?: Node | undefined;
+    environmentNode?: ShaderNodeObject<Node> | undefined;
+}
+interface CacheKeyData {
+    callId: number;
+    cacheKey: number;
 }
 declare module "../../../scenes/Scene.js" {
     interface Scene {
-        environmentNode?: Node | null | undefined;
-        backgroundNode?: Node | null | undefined;
-        fogNode?: Node | null | undefined;
+        environmentNode?: ShaderNodeObject<Node> | null | undefined;
+        backgroundNode?: ShaderNodeObject<Node> | null | undefined;
+        fogNode?: ShaderNodeObject<Node> | null | undefined;
     }
 }
+/**
+ * This renderer module manages node-related objects and is the
+ * primary interface between the renderer and the node system.
+ *
+ * @private
+ * @augments DataMap
+ */
 declare class Nodes extends DataMap<{
+    /**
+     * Constructs a new nodes management component.
+     *
+     * @param {Renderer} renderer - The renderer.
+     * @param {Backend} backend - The renderer's backend.
+     */
     nodeUniformsGroup: {
         key: NodeUniformsGroup;
         value: NodeUniformsGroupData;
@@ -68,30 +85,136 @@ declare class Nodes extends DataMap<{
     backend: Backend;
     nodeFrame: NodeFrame;
     nodeBuilderCache: Map<string, NodeBuilderState>;
-    callHashCache: ChainMap<readonly [Scene, LightsNode], {
-        callId: number;
-        cacheKey: string;
-    }>;
+    callHashCache: ChainMap<readonly [Scene, LightsNode], CacheKeyData>;
     groupsData: ChainMap<readonly [UniformGroupNode, NodeUniformsGroup], {
         version?: number;
     }>;
+    cacheLib: {
+        [type: string]: WeakMap<object, ShaderNodeObject<Node> | undefined>;
+    };
     constructor(renderer: Renderer, backend: Backend);
+    /**
+     * Returns `true` if the given node uniforms group must be updated or not.
+     *
+     * @param {NodeUniformsGroup} nodeUniformsGroup - The node uniforms group.
+     * @return {Boolean} Whether the node uniforms group requires an update or not.
+     */
     updateGroup(nodeUniformsGroup: NodeUniformsGroup): boolean;
+    /**
+     * Returns the cache key for the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Number} The cache key.
+     */
     getForRenderCacheKey(renderObject: RenderObject): string;
+    /**
+     * Returns a node builder state for the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {NodeBuilderState} The node builder state.
+     */
     getForRender(renderObject: RenderObject): NodeBuilderState;
+    /**
+     * Deletes the given object from the internal data map
+     *
+     * @param {Any} object - The object to delete.
+     * @return {Object?} The deleted dictionary.
+     */
     delete(
         object: NodeUniformsGroup | RenderObject | ComputeNode | Scene,
-    ): SceneData | RenderObjectData | NodeUniformsGroupData | ComputeNodeData;
+    ): RenderObjectData | NodeUniformsGroupData | ComputeNodeData | SceneData;
+    /**
+     * Returns a node builder state for the given compute node.
+     *
+     * @param {Node} computeNode - The compute node.
+     * @return {NodeBuilderState} The node builder state.
+     */
     getForCompute(computeNode: ComputeNode): NodeBuilderState;
+    /**
+     * Creates a node builder state for the given node builder.
+     *
+     * @private
+     * @param {NodeBuilder} nodeBuilder - The node builder.
+     * @return {NodeBuilderState} The node builder state.
+     */
     _createNodeBuilderState(nodeBuilder: NodeBuilder): NodeBuilderState;
-    getEnvironmentNode(scene: Scene): Node | null;
-    getBackgroundNode(scene: Scene): Node | null;
-    getFogNode(scene: Scene): Node | null;
-    getCacheKey(scene: Scene, lightsNode: LightsNode): string;
-    updateScene(scene: Scene): void;
+    /**
+     * Returns an environment node for the current configured
+     * scene environment.
+     *
+     * @param {Scene} scene - The scene.
+     * @return {Node} A node representing the current scene environment.
+     */
+    getEnvironmentNode(scene: Scene): ShaderNodeObject<Node> | null;
+    /**
+     * Returns a background node for the current configured
+     * scene background.
+     *
+     * @param {Scene} scene - The scene.
+     * @return {Node} A node representing the current scene background.
+     */
+    getBackgroundNode(scene: Scene): ShaderNodeObject<Node> | null;
+    /**
+     * Returns a fog node for the current configured scene fog.
+     *
+     * @param {Scene} scene - The scene.
+     * @return {Node} A node representing the current scene fog.
+     */
+    getFogNode(scene: Scene): ShaderNodeObject<Node> | null;
+    /**
+     * Returns a cache key for the given scene and lights node.
+     * This key is used by `RenderObject` as a part of the dynamic
+     * cache key (a key that must be checked every time the render
+     * objects is drawn).
+     *
+     * @param {Scene} scene - The scene.
+     * @param {LightsNode} lightsNode - The lights node.
+     * @return {Number} The cache key.
+     */
+    getCacheKey(scene: Scene, lightsNode: LightsNode): number;
+    /**
+     * A boolean that indicates whether tone mapping should be enabled
+     * or not.
+     *
+     * @type {Boolean}
+     */
     get isToneMappingState(): boolean;
+    /**
+     * If a scene background is configured, this method makes sure to
+     * represent the background with a corresponding node-based implementation.
+     *
+     * @param {Scene} scene - The scene.
+     */
     updateBackground(scene: Scene): void;
+    /**
+     * This method is part of the caching of nodes which are used to represents the
+     * scene's background, fog or environment.
+     *
+     * @param {String} type - The type of object to cache.
+     * @param {Object} object - The object.
+     * @param {Function} callback - A callback that produces a node representation for the given object.
+     * @param {Boolean} [forceUpdate=false] - Whether an update should be enforced or not.
+     * @return {Node} The node representation.
+     */
+    getCacheNode(
+        type: string,
+        object: object,
+        callback: () => ShaderNodeObject<Node> | undefined,
+        forceUpdate?: boolean,
+    ): ShaderNodeObject<Node> | undefined;
+    /**
+     * If a scene fog is configured, this method makes sure to
+     * represent the fog with a corresponding node-based implementation.
+     *
+     * @param {Scene} scene - The scene.
+     */
     updateFog(scene: Scene): void;
+    /**
+     * If a scene environment is configured, this method makes sure to
+     * represent the environment with a corresponding node-based implementation.
+     *
+     * @param {Scene} scene - The scene.
+     */
     updateEnvironment(scene: Scene): void;
     getNodeFrame(
         renderer?: Renderer,
@@ -101,14 +224,66 @@ declare class Nodes extends DataMap<{
         material?: Material | null,
     ): NodeFrame;
     getNodeFrameForRender(renderObject: RenderObject): NodeFrame;
+    /**
+     * Returns the current output cache key.
+     *
+     * @return {String} The output cache key.
+     */
     getOutputCacheKey(): string;
+    /**
+     * Checks if the output configuration (tone mapping and color space) for
+     * the given target has changed.
+     *
+     * @param {Texture} outputTarget - The output target.
+     * @return {Boolean} Whether the output configuration has changed or not.
+     */
     hasOutputChange(outputTarget: Texture): boolean;
-    getOutputNode(outputTexture: Texture): ShaderNodeObject<Node>;
+    /**
+     * Returns a node that represents the output configuration (tone mapping and
+     * color space) for the current target.
+     *
+     * @param {Texture} outputTarget - The output target.
+     * @return {Node} The output node.
+     */
+    getOutputNode(outputTarget: Texture): ShaderNodeObject<Node>;
+    /**
+     * Triggers the call of `updateBefore()` methods
+     * for all nodes of the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     */
     updateBefore(renderObject: RenderObject): void;
+    /**
+     * Triggers the call of `updateAfter()` methods
+     * for all nodes of the given render object.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     */
     updateAfter(renderObject: RenderObject): void;
+    /**
+     * Triggers the call of `update()` methods
+     * for all nodes of the given compute node.
+     *
+     * @param {Node} computeNode - The compute node.
+     */
     updateForCompute(computeNode: ComputeNode): void;
+    /**
+     * Triggers the call of `update()` methods
+     * for all nodes of the given compute node.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     */
     updateForRender(renderObject: RenderObject): void;
+    /**
+     * Returns `true` if the given render object requires a refresh.
+     *
+     * @param {RenderObject} renderObject - The render object.
+     * @return {Boolean} Whether the given render object requires a refresh or not.
+     */
     needsRefresh(renderObject: RenderObject): boolean;
+    /**
+     * Frees the internal resources.
+     */
     dispose(): void;
 }
 export default Nodes;

three/src/renderers/webgpu/WebGPUBackend.d.ts

@@ -1,6 +1,6 @@
 /// <reference types="@webgpu/types" />
 
-import { CoordinateSystem } from "../../constants.js";
+import { CoordinateSystem, HalfFloatType, UnsignedByteType } from "../../constants.js";
 import Backend, { BackendParameters } from "../common/Backend.js";
 
 export interface WebGPUBackendParameters extends BackendParameters {
@@ -10,6 +10,7 @@ export interface WebGPUBackendParameters extends BackendParameters {
     device?: GPUDevice | undefined;
     powerPreference?: GPUPowerPreference | undefined;
     context?: GPUCanvasContext | undefined;
+    outputType?: typeof UnsignedByteType | typeof HalfFloatType | undefined;
 }
 
 export default class WebGPUBackend extends Backend {

three/src/renderers/webgpu/nodes/BasicNodeLibrary.d.ts

@@ -1,5 +1,15 @@
 import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+/**
+ * This version of a node library represents a basic version
+ * just focusing on lights and tone mapping techniques.
+ *
+ * @private
+ * @augments NodeLibrary
+ */
 declare class BasicNodeLibrary extends NodeLibrary {
+    /**
+     * Constructs a new basic node library.
+     */
     constructor();
 }
 export default BasicNodeLibrary;

three/src/renderers/webgpu/nodes/StandardNodeLibrary.d.ts

@@ -1,5 +1,16 @@
 import NodeLibrary from "../../common/nodes/NodeLibrary.js";
+/**
+ * This version of a node library represents the standard version
+ * used in {@link WebGPURenderer}. It maps lights, tone mapping
+ * techniques and materials to node-based implementations.
+ *
+ * @private
+ * @augments NodeLibrary
+ */
 declare class StandardNodeLibrary extends NodeLibrary {
+    /**
+     * Constructs a new standard node library.
+     */
     constructor();
 }
 export default StandardNodeLibrary;

three/src/textures/DataTexture.d.ts

@@ -51,7 +51,7 @@ export class DataTexture extends Texture {
      * @param colorSpace See {@link Texture.colorSpace | .colorSpace}. Default {@link NoColorSpace}
      */
     constructor(
-        data?: BufferSource | null,
+        data?: ArrayBufferView | null,
         width?: number,
         height?: number,
         format?: PixelFormat,
@@ -111,7 +111,7 @@ export class DataTexture extends Texture {
 }
 
 export interface TextureImageData {
-    data: Uint8Array | Uint8ClampedArray;
+    data: ArrayBufferView;
     height: number;
     width: number;
 }

three/src/textures/Texture.d.ts

@@ -10,6 +10,7 @@ import {
     Wrapping,
 } from "../constants.js";
 import { EventDispatcher } from "../core/EventDispatcher.js";
+import { RenderTarget } from "../core/RenderTarget.js";
 import { Matrix3 } from "../math/Matrix3.js";
 import { Vector2 } from "../math/Vector2.js";
 import { CompressedTextureMipmap } from "./CompressedTexture.js";
@@ -426,6 +427,8 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
      */
     static DEFAULT_MAPPING: Mapping;
 
+    renderTarget: RenderTarget | null;
+
     /**
      * A callback function, called when the texture is updated _(e.g., when needsUpdate has been set to true and then the texture is used)_.
      */
@@ -452,11 +455,8 @@ export class Texture extends EventDispatcher<{ dispose: {} }> {
     updateMatrix(): void;
 
     /**
-     * Make copy of the texture
-     * @remarks Note this is not a **"deep copy"**, the image is shared
-     * @remarks
-     * Besides, cloning a texture does not automatically mark it for a texture upload
-     * You have to set {@link needsUpdate | .needsUpdate} to `true` as soon as it's image property (the data source) is fully loaded or ready.
+     * Make copy of the texture. Note this is not a "deep copy", the image is shared. Cloning the texture automatically
+     * marks it for texture upload.
      */
     clone(): this;
 

three/src/textures/VideoFrameTexture.d.ts

@@ -0,0 +1,27 @@
+import {
+    MagnificationTextureFilter,
+    Mapping,
+    MinificationTextureFilter,
+    PixelFormat,
+    TextureDataType,
+    Wrapping,
+} from "../constants.js";
+import { VideoTexture } from "./VideoTexture.js";
+
+declare class VideoFrameTexture extends VideoTexture {
+    constructor(
+        mapping?: Mapping,
+        wrapS?: Wrapping,
+        wrapT?: Wrapping,
+        magFilter?: MagnificationTextureFilter,
+        minFilter?: MinificationTextureFilter,
+        format?: PixelFormat,
+        type?: TextureDataType,
+        anisotropy?: number,
+    );
+
+    // FIXME Replace with VideoFrame when we no longer need to support TypeScript 5.0
+    setFrame(frane: unknown): void;
+}
+
+export { VideoFrameTexture };

three/examples/jsm/animation/MMDAnimationHelper.d.ts

@@ -1,99 +0,0 @@
-import { AnimationClip, AnimationMixer, Audio, Bone, Camera, Mesh, Object3D, Quaternion, SkinnedMesh } from "three";
-
-import { CCDIKSolver } from "./CCDIKSolver.js";
-import { MMDPhysics } from "./MMDPhysics.js";
-
-export interface MMDAnimationHelperParameter {
-    sync?: boolean | undefined;
-    afterglow?: number | undefined;
-    resetPhysicsOnLoop?: boolean | undefined;
-    pmxAnimation?: boolean | undefined;
-}
-
-export interface MMDAnimationHelperAddParameter {
-    animation?: AnimationClip | AnimationClip[] | undefined;
-    physics?: boolean | undefined;
-    warmup?: number | undefined;
-    unitStep?: number | undefined;
-    maxStepNum?: number | undefined;
-    gravity?: number | undefined;
-    delayTime?: number | undefined;
-}
-
-export interface MMDAnimationHelperPoseParameter {
-    resetPose?: boolean | undefined;
-    ik?: boolean | undefined;
-    grant?: boolean | undefined;
-}
-
-export interface MMDAnimationHelperMixer {
-    looped: boolean;
-    mixer?: AnimationMixer | undefined;
-    ikSolver: CCDIKSolver;
-    grantSolver: GrantSolver;
-    physics?: MMDPhysics | undefined;
-    duration?: number | undefined;
-}
-
-/**
- * @deprecated The module has been deprecated and will be removed with r172. Please migrate to
- * https://github.com/takahirox/three-mmd-loader instead.
- */
-export class MMDAnimationHelper {
-    constructor(params?: MMDAnimationHelperParameter);
-    meshes: SkinnedMesh[];
-    camera: Camera | null;
-    cameraTarget: Object3D;
-    audio: Audio;
-    audioManager: AudioManager;
-    configuration: {
-        sync: boolean;
-        afterglow: number;
-        resetPhysicsOnLoop: boolean;
-        pmxAnimation: boolean;
-    };
-    enabled: {
-        animation: boolean;
-        ik: boolean;
-        grant: boolean;
-        physics: boolean;
-        cameraAnimation: boolean;
-    };
-    objects: WeakMap<SkinnedMesh | Camera | AudioManager, MMDAnimationHelperMixer>;
-    onBeforePhysics: (mesh: SkinnedMesh) => void;
-    sharedPhysics: boolean;
-    masterPhysics: null;
-
-    add(object: SkinnedMesh | Camera | Audio, params?: MMDAnimationHelperAddParameter): this;
-    remove(object: SkinnedMesh | Camera | Audio): this;
-    update(delta: number): this;
-    pose(mesh: SkinnedMesh, vpd: object, params?: MMDAnimationHelperPoseParameter): this;
-    enable(key: string, enabled: boolean): this;
-    createGrantSolver(mesh: SkinnedMesh): GrantSolver;
-}
-
-export interface AudioManagerParameter {
-    delayTime?: number | undefined;
-}
-
-export class AudioManager {
-    constructor(audio: Audio, params?: AudioManagerParameter);
-    audio: Audio;
-    elapsedTime: number;
-    currentTime: number;
-    delayTime: number;
-    audioDuration: number;
-    duration: number;
-
-    control(delta: number): this;
-}
-
-export class GrantSolver {
-    constructor(mesh: SkinnedMesh, grants: object[]);
-    mesh: SkinnedMesh;
-    grants: object[];
-
-    update(): this;
-    updateOne(gran: object[]): this;
-    addGrantRotation(bone: Bone, q: Quaternion, ratio: number): this;
-}

three/examples/jsm/animation/MMDPhysics.d.ts

@@ -1,128 +0,0 @@
-import { Bone, Euler, Matrix4, MeshBasicMaterial, Object3D, Quaternion, SkinnedMesh, Vector3 } from "three";
-
-export interface MMDPhysicsParameter {
-    unitStep?: number | undefined;
-    maxStepNum?: number | undefined;
-    gravity?: Vector3 | undefined;
-}
-
-/**
- * @deprecated The module has been deprecated and will be removed with r172. Please migrate to
- * https://github.com/takahirox/three-mmd-loader instead.
- */
-export class MMDPhysics {
-    constructor(
-        mesh: SkinnedMesh,
-        rigidBodyParams: object[],
-        constraintParams?: object[],
-        params?: MMDPhysicsParameter,
-    );
-    manager: ResourceManager;
-    mesh: SkinnedMesh;
-    unitStep: number;
-    maxStepNum: number;
-    gravity: Vector3;
-    world: null;
-    bodies: RigidBody[];
-    constraints: Constraint[];
-
-    update(delta: number): this;
-    reset(): this;
-    warmup(cycles: number): this;
-    setGravity(gravity: Vector3): this;
-    createHelper(): MMDPhysicsHelper;
-}
-
-export class ResourceManager {
-    constructor();
-    threeVector3s: Vector3[];
-    threeMatrix4s: Matrix4[];
-    threeQuaternions: Quaternion[];
-    threeEulers: Euler[];
-    transforms: object[];
-    quaternions: object[];
-    vector3s: object[];
-
-    allocThreeVector3(): void;
-    freeThreeVector3(v: Vector3): void;
-    allocThreeMatrix4(): void;
-    freeThreeMatrix4(m: Matrix4): void;
-    allocThreeQuaternion(): void;
-    freeThreeQuaternion(q: Quaternion): void;
-    allocThreeEuler(): void;
-    freeThreeEuler(e: Euler): void;
-    allocTransform(): void;
-    freeTransform(t: object): void;
-    allocQuaternion(): void;
-    freeQuaternion(q: object): void;
-    allocVector3(): void;
-    freeVector3(v: object): void;
-    setIdentity(): void;
-    getBasis(t: object): object;
-    getBasisAsMatrix3(t: object): object;
-    getOrigin(t: object): object;
-    setOrigin(t: object, v: object): void;
-    copyOrigin(t1: object, t2: object): void;
-    setBasis(t: object, q: object): void;
-    setBasisFromMatrix3(t: object, m: object): void;
-    setOriginFromArray3(t: object, a: number[]): void;
-    setOriginFromThreeVector3(t: object, v: Vector3): void;
-    setBasisFromArray3(t: object, a: number[]): void;
-    setBasisFromThreeQuaternion(t: object, a: Quaternion): void;
-    multiplyTransforms(t1: object, t2: object): object;
-    inverseTransform(t: object): object;
-    multiplyMatrices3(m1: object, m2: object): object;
-    addVector3(v1: object, v2: object): object;
-    dotVectors3(v1: object, v2: object): number;
-    rowOfMatrix3(m: object, i: number): object;
-    columnOfMatrix3(m: object, i: number): object;
-    negativeVector3(v: object): object;
-    multiplyMatrix3ByVector3(m: object, v: object): object;
-    transposeMatrix3(m: object): object;
-    quaternionToMatrix3(q: object): object;
-    matrix3ToQuaternion(m: object): object;
-}
-
-export class RigidBody {
-    constructor(mesh: SkinnedMesh, world: object, params: object, manager: ResourceManager);
-    mesh: SkinnedMesh;
-    world: object;
-    params: object;
-    manager: ResourceManager;
-
-    body: object;
-    bone: Bone;
-    boneOffsetForm: object;
-    boneOffsetFormInverse: object;
-
-    reset(): this;
-    updateFromBone(): this;
-    updateBone(): this;
-}
-
-export class Constraint {
-    constructor(
-        mesh: SkinnedMesh,
-        world: object,
-        bodyA: RigidBody,
-        bodyB: RigidBody,
-        params: object,
-        manager: ResourceManager,
-    );
-
-    mesh: SkinnedMesh;
-    world: object;
-    bodyA: RigidBody;
-    bodyB: RigidBody;
-    params: object;
-    manager: ResourceManager;
-}
-
-export class MMDPhysicsHelper extends Object3D {
-    mesh: SkinnedMesh;
-    physics: MMDPhysics;
-    materials: [MeshBasicMaterial, MeshBasicMaterial, MeshBasicMaterial];
-
-    constructor(mesh: SkinnedMesh, physics: MMDPhysics);
-    dispose(): void;
-}

three/examples/jsm/exporters/MMDExporter.d.ts

@@ -1,11 +0,0 @@
-import { Object3D } from "three";
-
-/**
- * @deprecated The module has been deprecated and will be removed with r172. Please migrate to
- * https://github.com/takahirox/three-mmd-loader instead.
- */
-export class MMDExporter {
-    constructor();
-
-    parseVpd(skin: Object3D, outputShiftJis: boolean, useOriginalBones: boolean): [] | Uint8Array;
-}

three/examples/jsm/loaders/MMDLoader.d.ts

@@ -1,60 +0,0 @@
-import { AnimationClip, Camera, FileLoader, Loader, LoadingManager, SkinnedMesh } from "three";
-
-export interface MMDLoaderAnimationObject {
-    animation: AnimationClip;
-    mesh: SkinnedMesh;
-}
-
-/**
- * @deprecated The module has been deprecated and will be removed with r172. Please migrate to
- * https://github.com/takahirox/three-mmd-loader instead.
- */
-export class MMDLoader extends Loader<SkinnedMesh> {
-    constructor(manager?: LoadingManager);
-    animationBuilder: object;
-    animationPath: string;
-    loader: FileLoader;
-    meshBuilder: object;
-    parser: object | null;
-
-    loadAnimation(
-        url: string,
-        object: SkinnedMesh | Camera,
-        onLoad: (object: SkinnedMesh | AnimationClip) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadPMD(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadPMX(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadVMD(
-        url: string,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadVPD(
-        url: string,
-        isUnicode: boolean,
-        onLoad: (object: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadWithAnimation(
-        url: string,
-        vmdUrl: string | string[],
-        onLoad: (object: MMDLoaderAnimationObject) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    setAnimationPath(animationPath: string): this;
-}