three-stdlib 2.35.6 → 2.35.8

package/loaders/DRACOLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, BufferGeometry } from 'three'
+import type { Loader, LoadingManager, BufferGeometry } from 'three'
 
 export class DRACOLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/EXRLoader.d.cts

@@ -0,0 +1,18 @@
+import type { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
+
+export interface EXR {
+  header: object
+  width: number
+  height: number
+  data: Float32Array
+  format: PixelFormat
+  type: TextureDataType
+}
+
+export class EXRLoader extends DataTextureLoader {
+  constructor(manager?: LoadingManager)
+  type: TextureDataType
+
+  parse(buffer: ArrayBuffer): EXR
+  setDataType(type: TextureDataType): this
+}

package/loaders/EXRLoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
+import type { LoadingManager, DataTextureLoader, TextureDataType, PixelFormat } from 'three'
 
 export interface EXR {
   header: object

package/loaders/FBXLoader.d.cts

@@ -0,0 +1,14 @@
+import type { Loader, Group, LoadingManager } from 'three'
+
+export class FBXLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (object: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  parse(FBXBuffer: ArrayBuffer | string, path: string): Group
+}

package/loaders/FBXLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Group, LoadingManager } from 'three'
+import type { Loader, Group, LoadingManager } from 'three'
 
 export class FBXLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/FontLoader.d.cts

@@ -0,0 +1,37 @@
+import type { Loader } from 'three';
+import type { LoadingManager, Shape } from 'three';
+type Options = {
+    lineHeight: number;
+    letterSpacing: number;
+};
+export declare class FontLoader extends Loader {
+    constructor(manager?: LoadingManager);
+    load(url: string, onLoad?: (responseFont: Font) => void, onProgress?: (event: ProgressEvent) => void, onError?: (event: ErrorEvent) => void): void;
+    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Font>;
+    parse(json: FontData): Font;
+}
+type Glyph = {
+    _cachedOutline: string[];
+    ha: number;
+    o: string;
+};
+type FontData = {
+    boundingBox: {
+        yMax: number;
+        yMin: number;
+    };
+    familyName: string;
+    glyphs: {
+        [k: string]: Glyph;
+    };
+    resolution: number;
+    underlineThickness: number;
+};
+export declare class Font {
+    data: FontData;
+    isFont: boolean;
+    type: string;
+    constructor(data: FontData);
+    generateShapes(text: string, size?: number, _options?: Partial<Options>): Shape[];
+}
+export {};

package/loaders/FontLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader } from 'three';
+import type { Loader } from 'three';
 import type { LoadingManager, Shape } from 'three';
 type Options = {
     lineHeight: number;

package/loaders/GCodeLoader.d.cts

@@ -0,0 +1,15 @@
+import type { Loader, Group, LoadingManager } from 'three'
+
+export class GCodeLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  splitLayer: boolean
+
+  load(
+    url: string,
+    onLoad: (object: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  parse(data: string): Group
+}

package/loaders/GCodeLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, Group, LoadingManager } from 'three'
+import type { Loader, Group, LoadingManager } from 'three'
 
 export class GCodeLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/GLTFLoader.d.cts

@@ -0,0 +1,155 @@
+import type {
+  AnimationClip,
+  BufferAttribute,
+  BufferGeometry,
+  Camera,
+  Group,
+  InterleavedBufferAttribute,
+  LoadingManager,
+  Mesh,
+  MeshStandardMaterial,
+  Object3D,
+  Material,
+  SkinnedMesh,
+  Texture,
+  TextureLoader,
+  FileLoader,
+  ImageBitmapLoader,
+  Skeleton,
+  Loader,
+} from 'three'
+
+import type { DRACOLoader } from './DRACOLoader.d.cts'
+import type { KTX2Loader } from './KTX2Loader.d.cts'
+
+export interface GLTF {
+  animations: AnimationClip[]
+  scene: Group
+  scenes: Group[]
+  cameras: Camera[]
+  asset: {
+    copyright?: string | undefined
+    generator?: string | undefined
+    version?: string | undefined
+    minVersion?: string | undefined
+    extensions?: any
+    extras?: any
+  }
+  parser: GLTFParser
+  userData: any
+}
+
+export class GLTFLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  dracoLoader: DRACOLoader | null
+
+  load(
+    url: string,
+    onLoad: (gltf: GLTF) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<GLTF>
+
+  setDRACOLoader(dracoLoader: DRACOLoader): GLTFLoader
+
+  register(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader
+  unregister(callback: (parser: GLTFParser) => GLTFLoaderPlugin): GLTFLoader
+
+  setKTX2Loader(ktx2Loader: KTX2Loader): GLTFLoader
+  setMeshoptDecoder(meshoptDecoder: /* MeshoptDecoder */ any): GLTFLoader
+
+  parse(
+    data: ArrayBuffer | string,
+    path: string,
+    onLoad: (gltf: GLTF) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+
+  parseAsync(data: ArrayBuffer | string, path: string): Promise<GLTF>
+}
+
+export type GLTFReferenceType = 'materials' | 'nodes' | 'textures' | 'meshes'
+
+export interface GLTFReference {
+  materials?: number
+  nodes?: number
+  textures?: number
+  meshes?: number
+}
+
+export class GLTFParser {
+  json: any
+
+  options: {
+    path: string
+    manager: LoadingManager
+    ktx2Loader: KTX2Loader
+    meshoptDecoder: /* MeshoptDecoder */ any
+    crossOrigin: string
+    requestHeader: { [header: string]: string }
+  }
+
+  fileLoader: FileLoader
+  textureLoader: TextureLoader | ImageBitmapLoader
+  plugins: { [name: string]: GLTFLoaderPlugin }
+  extensions: { [name: string]: any }
+  associations: Map<Object3D | Material | Texture, GLTFReference>
+
+  setExtensions(extensions: { [name: string]: any }): void
+  setPlugins(plugins: { [name: string]: GLTFLoaderPlugin }): void
+
+  parse(onLoad: (gltf: GLTF) => void, onError?: (event: ErrorEvent) => void): void
+
+  getDependency: (type: string, index: number) => Promise<any>
+  getDependencies: (type: string) => Promise<any[]>
+  loadBuffer: (bufferIndex: number) => Promise<ArrayBuffer>
+  loadBufferView: (bufferViewIndex: number) => Promise<ArrayBuffer>
+  loadAccessor: (accessorIndex: number) => Promise<BufferAttribute | InterleavedBufferAttribute>
+  loadTexture: (textureIndex: number) => Promise<Texture>
+  loadTextureImage: (textureIndex: number, sourceIndex: number, loader: Loader) => Promise<Texture>
+  loadImageSource: (sourceIndex: number, loader: Loader) => Promise<Texture>
+  assignTexture: (
+    materialParams: { [key: string]: any },
+    mapName: string,
+    mapDef: {
+      index: number
+      texCoord?: number | undefined
+      extensions?: any
+    },
+  ) => Promise<void>
+  assignFinalMaterial: (object: Mesh) => void
+  getMaterialType: () => typeof MeshStandardMaterial
+  loadMaterial: (materialIndex: number) => Promise<Material>
+  createUniqueName: (originalName: string) => string
+  createNodeMesh: (nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh>
+  loadGeometries: (
+    /**
+     * GLTF.Primitive[]
+     * See: https://github.com/KhronosGroup/glTF/blob/master/specification/2.0/schema/mesh.primitive.schema.json
+     */
+    primitives: Array<{ [key: string]: any }>,
+  ) => Promise<BufferGeometry[]>
+  loadMesh: (meshIndex: number) => Promise<Group | Mesh | SkinnedMesh>
+  loadCamera: (cameraIndex: number) => Promise<Camera>
+  loadSkin: (skinIndex: number) => Promise<Skeleton>
+  loadAnimation: (animationIndex: number) => Promise<AnimationClip>
+  loadNode: (nodeIndex: number) => Promise<Object3D>
+  loadScene: () => Promise<Group>
+}
+
+export interface GLTFLoaderPlugin {
+  beforeRoot?: (() => Promise<void> | null) | undefined
+  afterRoot?: ((result: GLTF) => Promise<void> | null) | undefined
+  loadNode?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined
+  loadMesh?: ((meshIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined
+  loadBufferView?: ((bufferViewIndex: number) => Promise<ArrayBuffer> | null) | undefined
+  loadMaterial?: ((materialIndex: number) => Promise<Material> | null) | undefined
+  loadTexture?: ((textureIndex: number) => Promise<Texture> | null) | undefined
+  getMaterialType?: ((materialIndex: number) => typeof Material | null) | undefined
+  extendMaterialParams?:
+    | ((materialIndex: number, materialParams: { [key: string]: any }) => Promise<any> | null)
+    | undefined
+  createNodeMesh?: ((nodeIndex: number) => Promise<Group | Mesh | SkinnedMesh> | null) | undefined
+  createNodeAttachment?: ((nodeIndex: number) => Promise<Object3D> | null) | undefined
+}

package/loaders/GLTFLoader.d.ts

@@ -1,4 +1,4 @@
-import {
+import type {
   AnimationClip,
   BufferAttribute,
   BufferGeometry,
@@ -19,8 +19,8 @@ import {
   Loader,
 } from 'three'
 
-import { DRACOLoader } from './DRACOLoader'
-import { KTX2Loader } from './KTX2Loader'
+import type { DRACOLoader } from './DRACOLoader.d.ts'
+import type { KTX2Loader } from './KTX2Loader.d.ts'
 
 export interface GLTF {
   animations: AnimationClip[]

package/loaders/HDRCubeTextureLoader.d.cts

@@ -0,0 +1,18 @@
+import type { Loader, CubeTexture, LoadingManager, TextureDataType } from 'three'
+
+import type { RGBELoader } from './RGBELoader.d.cts'
+
+export class HDRCubeTextureLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  hdrLoader: RGBELoader
+  type: TextureDataType
+
+  load(
+    urls: string | string[],
+    onLoad: (texture: CubeTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): CubeTexture
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CubeTexture>
+  setDataType(type: TextureDataType): this
+}

package/loaders/HDRCubeTextureLoader.d.ts

@@ -1,6 +1,6 @@
-import { Loader, CubeTexture, LoadingManager, TextureDataType } from 'three'
+import type { Loader, CubeTexture, LoadingManager, TextureDataType } from 'three'
 
-import { RGBELoader } from './RGBELoader'
+import type { RGBELoader } from './RGBELoader.d.ts'
 
 export class HDRCubeTextureLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/KMZLoader.d.cts

@@ -0,0 +1,16 @@
+import type { Loader, LoadingManager } from 'three'
+
+import type { Collada } from './ColladaLoader.d.cts'
+
+export class KMZLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (kmz: Collada) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Collada>
+  parse(data: ArrayBuffer): Collada
+}

package/loaders/KMZLoader.d.ts

@@ -1,6 +1,6 @@
-import { Loader, LoadingManager } from 'three'
+import type { Loader, LoadingManager } from 'three'
 
-import { Collada } from './ColladaLoader'
+import type { Collada } from './ColladaLoader.d.ts'
 
 export class KMZLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/KTX2Loader.d.cts

@@ -0,0 +1,10 @@
+import type { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from 'three'
+
+export class KTX2Loader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager)
+
+  setTranscoderPath(path: string): KTX2Loader
+  setWorkerLimit(limit: number): KTX2Loader
+  detectSupport(renderer: WebGLRenderer): KTX2Loader
+  dispose(): KTX2Loader
+}

package/loaders/KTX2Loader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from 'three'
+import type { LoadingManager, CompressedTextureLoader, CompressedTexture, WebGLRenderer } from 'three'
 
 export class KTX2Loader extends CompressedTextureLoader {
   constructor(manager?: LoadingManager)

package/loaders/KTXLoader.d.cts

@@ -0,0 +1,16 @@
+import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
+
+export interface KTX {
+  mipmaps: object[]
+  width: number
+  height: number
+  format: PixelFormat | CompressedPixelFormat
+  mipmapCount: number
+  isCubemap: boolean
+}
+
+export class KTXLoader extends CompressedTextureLoader {
+  constructor(manager?: LoadingManager)
+
+  parse(buffer: ArrayBuffer, loadMipmaps: boolean): KTX
+}

package/loaders/KTXLoader.d.ts

@@ -1,4 +1,4 @@
-import { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
+import type { LoadingManager, CompressedTextureLoader, PixelFormat, CompressedPixelFormat } from 'three'
 
 export interface KTX {
   mipmaps: object[]

package/loaders/LDrawLoader.d.cts

@@ -0,0 +1,26 @@
+import type { Loader, LoadingManager, Group, Material } from 'three'
+
+export class LDrawLoader extends Loader {
+  materials: Material[]
+  materialsLibrary: Record<string, Material>
+  fileMap: Record<string, string>
+  smoothNormals: boolean
+
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (data: Group) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Group>
+  preloadMaterials(url: string): Promise<void>
+  setFileMap(fileMap: Record<string, string>): void
+  setMaterials(materials: Material[]): void
+
+  parse(text: string, path: string, onLoad: (data: Group) => void): void
+
+  addMaterial(material: Material): void
+  getMaterial(colourCode: string): Material | null
+}

package/loaders/LDrawLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Group, Material } from 'three'
+import type { Loader, LoadingManager, Group, Material } from 'three'
 
 export class LDrawLoader extends Loader {
   materials: Material[]

package/loaders/LUT3dlLoader.d.cts

@@ -0,0 +1,20 @@
+import type { Loader, LoadingManager, DataTexture, Texture } from 'three'
+
+export interface LUT3dlResult {
+  size: number
+  texture: DataTexture
+  texture3D: Texture // Data3DTexture
+}
+
+export class LUT3dlLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: LUT3dlResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: Error) => void,
+  ): any
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUT3dlResult>
+  parse(data: string): LUT3dlResult
+}

package/loaders/LUT3dlLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, DataTexture, Texture } from 'three'
+import type { Loader, LoadingManager, DataTexture, Texture } from 'three'
 
 export interface LUT3dlResult {
   size: number

package/loaders/LUTCubeLoader.d.cts

@@ -0,0 +1,23 @@
+import type { Loader, LoadingManager, Vector3, DataTexture, Texture } from 'three'
+
+export interface LUTCubeResult {
+  title: string
+  size: number
+  domainMin: Vector3
+  domainMax: Vector3
+  texture: DataTexture
+  texture3D: Texture // Data3DTexture
+}
+
+export class LUTCubeLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: LUTCubeResult) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: Error) => void,
+  ): any
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LUTCubeResult>
+  parse(data: string): LUTCubeResult
+}

package/loaders/LUTCubeLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Vector3, DataTexture, Texture } from 'three'
+import type { Loader, LoadingManager, Vector3, DataTexture, Texture } from 'three'
 
 export interface LUTCubeResult {
   title: string

package/loaders/LWOLoader.d.cts

@@ -0,0 +1,26 @@
+import type { Loader, LoadingManager, Material, Object3D } from 'three'
+
+export interface LWO {
+  materials: Material[]
+  meshes: Object3D[]
+}
+
+export interface LWOLoaderParameters {
+  /**
+   * Base content delivery folder path, use when it differs from Lightwave default structure
+   */
+  resourcePath?: string
+}
+
+export class LWOLoader extends Loader {
+  constructor(manager?: LoadingManager, parameters?: LWOLoaderParameters)
+
+  load(
+    url: string,
+    onLoad: (lwo: LWO) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<LWO>
+  parse(data: ArrayBuffer, path: string, modelName: string): LWO
+}

package/loaders/LWOLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, LoadingManager, Material, Object3D } from 'three'
+import type { Loader, LoadingManager, Material, Object3D } from 'three'
 
 export interface LWO {
   materials: Material[]

package/loaders/LottieLoader.d.cts

@@ -0,0 +1,15 @@
+import type { Loader, CanvasTexture, LoadingManager } from 'three'
+
+export class LottieLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (texture: CanvasTexture) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CanvasTexture>
+
+  setQuality(value: number): void
+}

package/loaders/LottieLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, CanvasTexture, LoadingManager } from 'three'
+import type { Loader, CanvasTexture, LoadingManager } from 'three'
 
 export class LottieLoader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/MD2Loader.d.cts

@@ -0,0 +1,14 @@
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
+
+export class MD2Loader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (geometry: BufferGeometry) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<BufferGeometry>
+  parse(data: ArrayBuffer): BufferGeometry
+}

package/loaders/MD2Loader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, BufferGeometry, LoadingManager } from 'three'
+import type { Loader, BufferGeometry, LoadingManager } from 'three'
 
 export class MD2Loader extends Loader {
   constructor(manager?: LoadingManager)

package/loaders/MDDLoader.d.cts

@@ -0,0 +1,19 @@
+import type { Loader, AnimationClip, BufferAttribute, LoadingManager } from 'three'
+
+export interface MDD {
+  morphTargets: BufferAttribute[]
+  clip: AnimationClip
+}
+
+export class MDDLoader extends Loader {
+  constructor(manager?: LoadingManager)
+
+  load(
+    url: string,
+    onLoad: (result: MDD) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<MDD>
+  parse(data: ArrayBuffer): MDD
+}

package/loaders/MDDLoader.d.ts

@@ -1,4 +1,4 @@
-import { Loader, AnimationClip, BufferAttribute, LoadingManager } from 'three'
+import type { Loader, AnimationClip, BufferAttribute, LoadingManager } from 'three'
 
 export interface MDD {
   morphTargets: BufferAttribute[]

package/loaders/MMDLoader.d.cts

@@ -0,0 +1,63 @@
+import type { Loader, Camera, AnimationClip, FileLoader, LoadingManager, SkinnedMesh } from 'three'
+
+export interface MMDLoaderAnimationObject {
+  animation: AnimationClip
+  mesh: SkinnedMesh
+}
+
+export class MMDLoader extends Loader {
+  constructor(manager?: LoadingManager)
+  animationBuilder: object
+  animationPath: string
+  loader: FileLoader
+  meshBuilder: object
+  parser: object | null
+
+  load(
+    url: string,
+    onLoad: (mesh: SkinnedMesh) => void,
+    onProgress?: (event: ProgressEvent) => void,
+    onError?: (event: ErrorEvent) => void,
+  ): void
+  loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<SkinnedMesh>
+  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
+}