@types/three 0.155.0 → 0.156.0

three/src/core/Object3D.d.ts

@@ -1,19 +1,24 @@
-import { Vector3 } from './../math/Vector3.js';
-import { Euler } from './../math/Euler.js';
-import { Quaternion } from './../math/Quaternion.js';
-import { Matrix4 } from './../math/Matrix4.js';
-import { Matrix3 } from './../math/Matrix3.js';
+import { Vector3 } from '../math/Vector3.js';
+import { Euler } from '../math/Euler.js';
+import { Quaternion } from '../math/Quaternion.js';
+import { Matrix4 } from '../math/Matrix4.js';
+import { Matrix3 } from '../math/Matrix3.js';
 import { Layers } from './Layers.js';
-import { WebGLRenderer } from './../renderers/WebGLRenderer.js';
-import { Scene } from './../scenes/Scene.js';
-import { Camera } from './../cameras/Camera.js';
-import { Material } from './../materials/Material.js';
-import { Group } from './../objects/Group.js';
+import { WebGLRenderer } from '../renderers/WebGLRenderer.js';
+import { Scene } from '../scenes/Scene.js';
+import { Camera } from '../cameras/Camera.js';
+import { Material } from '../materials/Material.js';
+import { Group } from '../objects/Group.js';
 import { Intersection, Raycaster } from './Raycaster.js';
-import { EventDispatcher, BaseEvent, Event } from './EventDispatcher.js';
+import { EventDispatcher } from './EventDispatcher.js';
 import { BufferGeometry } from './BufferGeometry.js';
 import { AnimationClip } from '../animation/AnimationClip.js';
 
+export interface Object3DEventMap {
+    added: {};
+    removed: {};
+}
+
 /**
  * This is the base class for most objects in three.js and provides a set of properties and methods for manipulating objects in 3D space.
  * @remarks Note that this can be used for grouping objects via the {@link THREE.Object3D.add | .add()} method which adds the object as a child,
@@ -21,7 +26,7 @@ import { AnimationClip } from '../animation/AnimationClip.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/core/Object3D | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/Object3D.js | Source}
  */
-export class Object3D<E extends BaseEvent = Event> extends EventDispatcher<E> {
+export class Object3D<TEventMap extends Object3DEventMap = Object3DEventMap> extends EventDispatcher<TEventMap> {
     /**
      * This creates a new {@link Object3D} object.
      */

three/src/core/RenderTarget.d.ts

@@ -33,7 +33,7 @@ export interface RenderTargetOptions {
     encoding?: TextureEncoding | undefined;
 }
 
-export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher {
+export class RenderTarget<TTexture extends Texture | Texture[] = Texture> extends EventDispatcher<{ dispose: {} }> {
     constructor(width?: number, height?: number, options?: RenderTargetOptions);
 
     readonly isRenderTarget: true;

three/src/core/UniformsGroup.d.ts

@@ -6,7 +6,7 @@ import { Usage } from '../constants.js';
  * @see Example: {@link https://threejs.org/examples/#webgl2_ubo | WebGL2 / UBO}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/UniformsGroup.js | Source}
  */
-export class UniformsGroup extends EventDispatcher {
+export class UniformsGroup extends EventDispatcher<{ dispose: {} }> {
     constructor();
 
     readonly isUniformsGroup: true;

three/src/extras/core/Path.d.ts

@@ -75,7 +75,7 @@ export class Path extends CurvePath<Vector2> {
         aStartAngle: number,
         aEndAngle: number,
         aClockwise: boolean,
-        aRotation: number,
+        aRotation?: number,
     ): this;
 
     /**

three/src/loaders/AnimationLoader.d.ts

@@ -1,16 +1,9 @@
 import { LoadingManager } from './LoadingManager.js';
 import { Loader } from './Loader.js';
-import { AnimationClip } from './../animation/AnimationClip.js';
+import { AnimationClip } from '../animation/AnimationClip.js';
 
-export class AnimationLoader extends Loader {
+export class AnimationLoader extends Loader<AnimationClip[]> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (response: AnimationClip[]) => void,
-        onProgress?: (request: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<AnimationClip[]>;
-    parse(json: any): AnimationClip[];
+    parse(json: readonly unknown[]): AnimationClip[];
 }

three/src/loaders/AudioLoader.d.ts

@@ -1,15 +1,6 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
 
-export class AudioLoader extends Loader {
+export class AudioLoader extends Loader<AudioBuffer> {
     constructor(manager?: LoadingManager);
-
-    load(
-        url: string,
-        onLoad: (audioBuffer: AudioBuffer) => void,
-        onProgress?: (request: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<AudioBuffer>;
 }

three/src/loaders/BufferGeometryLoader.d.ts

@@ -1,20 +1,10 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { BufferGeometry } from './../core/BufferGeometry.js';
+import { BufferGeometry } from '../core/BufferGeometry.js';
 import { InstancedBufferGeometry } from '../core/InstancedBufferGeometry.js';
 
-export class BufferGeometryLoader extends Loader {
+export class BufferGeometryLoader extends Loader<InstancedBufferGeometry | BufferGeometry> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (bufferGeometry: InstancedBufferGeometry | BufferGeometry) => void,
-        onProgress?: (request: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(
-        url: string,
-        onProgress?: (event: ProgressEvent) => void,
-    ): Promise<InstancedBufferGeometry | BufferGeometry>;
-    parse(json: any): InstancedBufferGeometry | BufferGeometry;
+    parse(json: unknown): InstancedBufferGeometry | BufferGeometry;
 }

three/src/loaders/CompressedTextureLoader.d.ts

@@ -1,16 +1,14 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { CompressedTexture } from './../textures/CompressedTexture.js';
+import { CompressedTexture } from '../textures/CompressedTexture.js';
 
-export class CompressedTextureLoader extends Loader {
+export class CompressedTextureLoader extends Loader<CompressedTexture> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad: (texture: CompressedTexture) => void,
+        onLoad?: (data: CompressedTexture) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): CompressedTexture;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CompressedTexture>;
 }

three/src/loaders/CubeTextureLoader.d.ts

@@ -1,16 +1,14 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { CubeTexture } from './../textures/CubeTexture.js';
+import { CubeTexture } from '../textures/CubeTexture.js';
 
-export class CubeTextureLoader extends Loader {
+export class CubeTextureLoader extends Loader<CubeTexture, readonly string[]> {
     constructor(manager?: LoadingManager);
 
     load(
-        urls: string[],
-        onLoad?: (texture: CubeTexture) => void,
+        url: readonly string[],
+        onLoad?: (data: CubeTexture) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): CubeTexture;
-
-    loadAsync(urls: string[], onProgress?: (event: ProgressEvent) => void): Promise<CubeTexture>;
 }

three/src/loaders/DataTextureLoader.d.ts

@@ -1,16 +1,14 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { DataTexture } from './../textures/DataTexture.js';
+import { DataTexture } from '../textures/DataTexture.js';
 
-export class DataTextureLoader extends Loader {
+export class DataTextureLoader extends Loader<DataTexture> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad?: (dataTexture: DataTexture, texData: object) => void,
+        onLoad?: (data: DataTexture, texData: object) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): DataTexture;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<DataTexture>;
 }

three/src/loaders/FileLoader.d.ts

@@ -1,19 +1,12 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
 
-export class FileLoader extends Loader {
+export class FileLoader extends Loader<string | ArrayBuffer> {
     constructor(manager?: LoadingManager);
 
     mimeType: undefined | MimeType;
     responseType: undefined | string;
 
-    load(
-        url: string,
-        onLoad?: (response: string | ArrayBuffer) => void,
-        onProgress?: (request: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): any;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<string | ArrayBuffer>;
     setMimeType(mimeType: MimeType): FileLoader;
     setResponseType(responseType: string): FileLoader;
 }

three/src/loaders/ImageBitmapLoader.d.ts

@@ -1,7 +1,7 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
 
-export class ImageBitmapLoader extends Loader {
+export class ImageBitmapLoader extends Loader<ImageBitmap> {
     constructor(manager?: LoadingManager);
 
     /**
@@ -12,12 +12,4 @@ export class ImageBitmapLoader extends Loader {
     readonly isImageBitmapLoader: true;
 
     setOptions(options: object): ImageBitmapLoader;
-    load(
-        url: string,
-        onLoad?: (response: ImageBitmap) => void,
-        onProgress?: (request: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): any;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<ImageBitmap>;
 }

three/src/loaders/ImageLoader.d.ts

@@ -5,15 +5,13 @@ import { LoadingManager } from './LoadingManager.js';
  * A loader for loading an image.
  * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
  */
-export class ImageLoader extends Loader {
+export class ImageLoader extends Loader<HTMLImageElement> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad?: (image: HTMLImageElement) => void,
+        onLoad?: (data: HTMLImageElement) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): HTMLImageElement;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<HTMLImageElement>;
 }

three/src/loaders/Loader.d.ts

@@ -3,7 +3,7 @@ import { LoadingManager } from './LoadingManager.js';
 /**
  * Base class for implementing loaders.
  */
-export class Loader {
+export class Loader<TData = unknown, TUrl = string> {
     constructor(manager?: LoadingManager);
 
     /**
@@ -32,11 +32,13 @@ export class Loader {
      */
     requestHeader: { [header: string]: string };
 
-    /*
-	load(): void;
-    loadAsync(): Promise<unknown>;
-	parse(): void;
-	*/
+    load(
+        url: TUrl,
+        onLoad?: (data: TData) => void,
+        onProgress?: (event: ProgressEvent) => void,
+        onError?: (err: unknown) => void,
+    ): void;
+    loadAsync(url: TUrl, onProgress?: (event: ProgressEvent) => void): Promise<TData>;
 
     setCrossOrigin(crossOrigin: string): this;
     setWithCredentials(value: boolean): this;

three/src/loaders/MaterialLoader.d.ts

@@ -1,9 +1,9 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { Texture } from './../textures/Texture.js';
-import { Material } from './../materials/Material.js';
+import { Texture } from '../textures/Texture.js';
+import { Material } from '../materials/Material.js';
 
-export class MaterialLoader extends Loader {
+export class MaterialLoader extends Loader<Material> {
     constructor(manager?: LoadingManager);
 
     /**
@@ -11,13 +11,6 @@ export class MaterialLoader extends Loader {
      */
     textures: { [key: string]: Texture };
 
-    load(
-        url: string,
-        onLoad: (material: Material) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: Error | ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Material>;
     setTextures(textures: { [key: string]: Texture }): this;
-    parse(json: any): Material;
+    parse(json: unknown): Material;
 }

three/src/loaders/ObjectLoader.d.ts

@@ -8,35 +8,21 @@ import { InstancedBufferGeometry } from '../core/InstancedBufferGeometry.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
 import { Source } from '../textures/Source.js';
 
-export class ObjectLoader extends Loader {
+export class ObjectLoader extends Loader<Object3D> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad?: (object: Object3D) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: Error | ErrorEvent) => void,
-    ): void;
-    loadAsync<ObjectType extends Object3D>(
-        url: string,
-        onProgress?: (event: ProgressEvent) => void,
-    ): // tslint:disable-next-line:no-unnecessary-generics
-    Promise<ObjectType>;
-    // tslint:disable-next-line:no-unnecessary-generics
-    parse<T extends Object3D>(json: any, onLoad?: (object: Object3D) => void): T;
-    // tslint:disable-next-line:no-unnecessary-generics
-    parseAsync<T extends Object3D>(json: any): Promise<T>;
-    parseGeometries(json: any): { [key: string]: InstancedBufferGeometry | BufferGeometry };
-    parseMaterials(json: any, textures: { [key: string]: Texture }): { [key: string]: Material };
-    parseAnimations(json: any): AnimationClip[];
-    parseImages(json: any, onLoad?: () => void): { [key: string]: Source };
-    parseImagesAsync(json: any): Promise<{ [key: string]: Source }>;
-    parseTextures(json: any, images: { [key: string]: Source }): { [key: string]: Texture };
-    parseObject<T extends Object3D>(
-        data: any,
-        geometries: any[],
-        materials: Material[],
-        animations: AnimationClip[],
-    ): // tslint:disable-next-line:no-unnecessary-generics
-    T;
+    parse(json: unknown, onLoad?: (object: Object3D) => void): Object3D;
+    parseAsync(json: unknown): Promise<Object3D>;
+    parseGeometries(json: unknown): { [key: string]: InstancedBufferGeometry | BufferGeometry };
+    parseMaterials(json: unknown, textures: { [key: string]: Texture }): { [key: string]: Material };
+    parseAnimations(json: unknown): { [key: string]: AnimationClip };
+    parseImages(json: unknown, onLoad?: () => void): { [key: string]: Source };
+    parseImagesAsync(json: unknown): Promise<{ [key: string]: Source }>;
+    parseTextures(json: unknown, images: { [key: string]: Source }): { [key: string]: Texture };
+    parseObject(
+        data: unknown,
+        geometries: { [key: string]: InstancedBufferGeometry | BufferGeometry },
+        materials: { [key: string]: Material },
+        animations: { [key: string]: AnimationClip },
+    ): Object3D;
 }

three/src/loaders/TextureLoader.d.ts

@@ -1,20 +1,18 @@
 import { Loader } from './Loader.js';
 import { LoadingManager } from './LoadingManager.js';
-import { Texture } from './../textures/Texture.js';
+import { Texture } from '../textures/Texture.js';
 
 /**
  * Class for loading a texture.
  * Unlike other loaders, this one emits events instead of using predefined callbacks. So if you're interested in getting notified when things happen, you need to add listeners to the object.
  */
-export class TextureLoader extends Loader {
+export class TextureLoader extends Loader<Texture> {
     constructor(manager?: LoadingManager);
 
     load(
         url: string,
-        onLoad?: (texture: Texture) => void,
+        onLoad?: (data: Texture) => void,
         onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
+        onError?: (err: unknown) => void,
     ): Texture;
-
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Texture>;
 }

three/src/materials/Material.d.ts

@@ -63,7 +63,7 @@ export interface MaterialParameters {
 /**
  * Materials describe the appearance of objects. They are defined in a (mostly) renderer-independent way, so you don't have to rewrite materials if you decide to use a different renderer.
  */
-export class Material extends EventDispatcher {
+export class Material extends EventDispatcher<{ dispose: {} }> {
     constructor();
 
     alphaHash: boolean;

three/src/objects/Group.d.ts

@@ -1,4 +1,4 @@
-import { Object3D } from './../core/Object3D.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 
 /**
  * Its purpose is to make working with groups of objects syntactically clearer.
@@ -22,7 +22,7 @@ import { Object3D } from './../core/Object3D.js';
  * @see {@link https://threejs.org/docs/index.html#api/en/objects/Group | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/objects/Group.js | Source}
  */
-export class Group extends Object3D {
+export class Group<TEventMap extends Object3DEventMap = Object3DEventMap> extends Object3D<TEventMap> {
     /**
      * Creates a new {@link Group}.
      */

three/src/objects/InstancedMesh.d.ts

@@ -1,11 +1,16 @@
 import { BufferGeometry } from '../core/BufferGeometry.js';
-import { Material } from './../materials/Material.js';
-import { BufferAttribute } from './../core/BufferAttribute.js';
+import { Material } from '../materials/Material.js';
 import { InstancedBufferAttribute } from '../core/InstancedBufferAttribute.js';
 import { Mesh } from './Mesh.js';
-import { Matrix4 } from './../math/Matrix4.js';
-import { Color } from './../math/Color.js';
-import { Box3, Sphere } from '../Three.js';
+import { Matrix4 } from '../math/Matrix4.js';
+import { Color } from '../math/Color.js';
+import { Object3DEventMap } from '../core/Object3D.js';
+import { Box3 } from '../math/Box3.js';
+import { Sphere } from '../math/Sphere.js';
+
+export interface InstancedMeshEventMap extends Object3DEventMap {
+    dispose: {};
+}
 
 /**
  * A special version of {@link THREE.Mesh | Mesh} with instanced rendering support
@@ -23,7 +28,7 @@ import { Box3, Sphere } from '../Three.js';
 export class InstancedMesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Mesh<TGeometry, TMaterial> {
+> extends Mesh<TGeometry, TMaterial, InstancedMeshEventMap> {
     /**
      * Create a new instance of {@link InstancedMesh}
      * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}.

three/src/objects/Mesh.d.ts

@@ -1,8 +1,6 @@
-import { Material } from './../materials/Material.js';
-import { Raycaster } from './../core/Raycaster.js';
-import { Object3D } from './../core/Object3D.js';
+import { Material } from '../materials/Material.js';
+import { Object3D, Object3DEventMap } from '../core/Object3D.js';
 import { BufferGeometry } from '../core/BufferGeometry.js';
-import { Intersection } from '../core/Raycaster.js';
 import { Vector3 } from '../math/Vector3.js';
 
 /**
@@ -24,7 +22,8 @@ import { Vector3 } from '../math/Vector3.js';
 export class Mesh<
     TGeometry extends BufferGeometry = BufferGeometry,
     TMaterial extends Material | Material[] = Material | Material[],
-> extends Object3D {
+    TEventMap extends Object3DEventMap = Object3DEventMap,
+> extends Object3D<TEventMap> {
     /**
      * Create a new instance of {@link Mesh}
      * @param geometry An instance of {@link THREE.BufferGeometry | BufferGeometry}. Default {@link THREE.BufferGeometry | `new THREE.BufferGeometry()`}.

three/src/renderers/webxr/WebXRController.d.ts

@@ -1,5 +1,6 @@
 import { Group } from '../../objects/Group.js';
 import { Vector3 } from '../../math/Vector3.js';
+import { Object3DEventMap } from '../../core/Object3D.js';
 
 export type XRControllerEventType = XRSessionEventType | XRInputSourceEventType | 'disconnected' | 'connected';
 
@@ -13,19 +14,36 @@ export interface XRHandInputState {
     pinching: boolean;
 }
 
-export class XRHandSpace extends Group {
+export interface WebXRSpaceEventMap extends Object3DEventMap {
+    select: { data: XRInputSource };
+    selectstart: { data: XRInputSource };
+    selectend: { data: XRInputSource };
+    squeeze: { data: XRInputSource };
+    squeezestart: { data: XRInputSource };
+    squeezeend: { data: XRInputSource };
+
+    connected: { data: XRInputSource };
+    disconnected: { data: XRInputSource };
+
+    pinchend: { handedness: XRHandedness; target: WebXRController }; // This Event break the THREE.EventDispatcher contract, replacing the target to the wrong instance.
+    pinchstart: { handedness: XRHandedness; target: WebXRController }; // This Event break the THREE.EventDispatcher contract, replacing the target to the wrong instance.
+
+    move: {};
+}
+
+export class XRHandSpace extends Group<WebXRSpaceEventMap> {
     readonly joints: Partial<XRHandJoints>;
     readonly inputState: XRHandInputState;
 }
 
-export class XRTargetRaySpace extends Group {
+export class XRTargetRaySpace extends Group<WebXRSpaceEventMap> {
     hasLinearVelocity: boolean;
     readonly linearVelocity: Vector3;
     hasAngularVelocity: boolean;
     readonly angularVelocity: Vector3;
 }
 
-export class XRGripSpace extends Group {
+export class XRGripSpace extends Group<WebXRSpaceEventMap> {
     hasLinearVelocity: boolean;
     readonly linearVelocity: Vector3;
     hasAngularVelocity: boolean;

three/src/renderers/webxr/WebXRManager.d.ts

@@ -11,7 +11,16 @@ import { XRTargetRaySpace, XRGripSpace, XRHandSpace } from './WebXRController.js
 export type WebXRCamera = PerspectiveCamera & { viewport: Vector4 };
 export type WebXRArrayCamera = Omit<ArrayCamera, 'cameras'> & { cameras: [WebXRCamera, WebXRCamera] };
 
-export class WebXRManager extends EventDispatcher {
+export interface WebXRManagerEventMap {
+    sessionstart: {};
+    sessionend: {};
+    planeadded: { data: XRPlane };
+    planeremoved: { data: XRPlane };
+    planechanged: { data: XRPlane };
+    planesdetected: { data: XRPlaneSet };
+}
+
+export class WebXRManager extends EventDispatcher<WebXRManagerEventMap> {
     constructor(renderer: any, gl: WebGLRenderingContext);
 
     /**

three/src/textures/Texture.d.ts

@@ -1,7 +1,7 @@
-import { Vector2 } from './../math/Vector2.js';
-import { Matrix3 } from './../math/Matrix3.js';
+import { Vector2 } from '../math/Vector2.js';
+import { Matrix3 } from '../math/Matrix3.js';
 import { Source } from './Source.js';
-import { EventDispatcher } from './../core/EventDispatcher.js';
+import { EventDispatcher } from '../core/EventDispatcher.js';
 import {
     Mapping,
     Wrapping,
@@ -38,7 +38,7 @@ export interface OffscreenCanvas extends EventTarget {}
  * @see {@link https://threejs.org/docs/index.html#api/en/textures/Texture | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/Textures/Texture.js | Source}
  */
-export class Texture extends EventDispatcher {
+export class Texture extends EventDispatcher<{ dispose: {} }> {
     /**
      * This creates a new {@link THREE.Texture | Texture} object.
      * @param image See {@link Texture.image | .image}. Default {@link THREE.Texture.DEFAULT_IMAGE}

three/src/utils.d.ts

@@ -0,0 +1 @@
+export function createCanvasElement(): HTMLCanvasElement;

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

@@ -1,32 +0,0 @@
-import { CompressedTexture, Loader, LoadingManager, WebGLRenderer } from '../../../src/Three.js';
-
-export class BasisTextureLoader extends Loader {
-    constructor(manager?: LoadingManager);
-    transcoderBinary: ArrayBuffer | null;
-    transcoderPath: string;
-    transcoderPending: Promise<void> | null;
-
-    workerConfig: {
-        format: number;
-        astcSupported: boolean;
-        etcSupported: boolean;
-        dxtSupported: boolean;
-        pvrtcSupported: boolean;
-    };
-    workerLimit: number;
-    workerNextTaskID: number;
-    workerPool: object[];
-    workerSourceURL: string;
-
-    detectSupport(renderer: WebGLRenderer): this;
-    load(
-        url: string,
-        onLoad: (texture: CompressedTexture) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<CompressedTexture>;
-    setTranscoderPath(path: string): this;
-    setWorkerLimit(workerLimit: number): this;
-    dispose(): void;
-}