@types/three 0.155.1 → 0.156.0

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

@@ -1,15 +1,8 @@
 import { Points, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class PCDLoader extends Loader {
+export class PCDLoader extends Loader<Points> {
     constructor(manager?: LoadingManager);
     littleEndian: boolean;
 
-    load(
-        url: string,
-        onLoad: (points: Points) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Points>;
     parse(data: ArrayBuffer | string): Points;
 }

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

@@ -8,15 +8,8 @@ export interface PDB {
     };
 }
 
-export class PDBLoader extends Loader {
+export class PDBLoader extends Loader<PDB> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (pdb: PDB) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<PDB>;
     parse(text: string): PDB;
 }

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

@@ -1,17 +1,10 @@
 import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class PLYLoader extends Loader {
+export class PLYLoader extends Loader<BufferGeometry> {
     constructor(manager?: LoadingManager);
     propertyNameMapping: object;
     customPropertyMapping: Record<string, any>;
 
-    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>;
     setPropertyNameMapping(mapping: object): void;
     setCustomPropertyNameMapping(mapping: Record<string, any>): void;
     parse(data: ArrayBuffer | string): BufferGeometry;

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

@@ -1,14 +1,7 @@
 import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class STLLoader extends Loader {
+export class STLLoader extends Loader<BufferGeometry> {
     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 | string): BufferGeometry;
 }

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

@@ -21,19 +21,12 @@ export interface StrokeStyle {
     strokeMiterLimit: number;
 }
 
-export class SVGLoader extends Loader {
+export class SVGLoader extends Loader<SVGResult> {
     constructor(manager?: LoadingManager);
 
     defaultDPI: number;
     defaultUnit: string;
 
-    load(
-        url: string,
-        onLoad: (data: SVGResult) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<SVGResult>;
     parse(text: string): SVGResult;
 
     static getStrokeStyle(

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

@@ -1,6 +1,6 @@
 import { Color, Group, Loader, LoadingManager, Material, Mesh, Texture } from '../../../src/Three.js';
 
-export class TDSLoader extends Loader {
+export class TDSLoader extends Loader<Group> {
     constructor(manager?: LoadingManager);
     debug: boolean;
     group: Group;
@@ -9,13 +9,6 @@ export class TDSLoader extends Loader {
     meshes: Mesh[];
     position: number;
 
-    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(arraybuffer: ArrayBuffer, path: string): Group;
 
     debugMessage(message: object): void;

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

@@ -3,12 +3,5 @@ import { DataTexture, DataTextureLoader, LoadingManager } from '../../../src/Thr
 export class TGALoader extends DataTextureLoader {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad?: (texture: DataTexture, texData: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): DataTexture;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<DataTexture>;
     parse(data: ArrayBuffer): DataTexture;
 }

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

@@ -1,15 +1,8 @@
 import { Loader, LoadingManager } from '../../../src/Three.js';
 
-export class TTFLoader extends Loader {
+export class TTFLoader extends Loader<object> {
     constructor(manager?: LoadingManager);
     reversed: boolean;
 
-    load(
-        url: string,
-        onLoad: (json: object) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<object>;
     parse(arraybuffer: ArrayBuffer): object;
 }

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

@@ -1,14 +1,7 @@
 import { Loader, LoadingManager, Group } from '../../../src/Three.js';
 
-export class TiltLoader extends Loader {
+export class TiltLoader extends Loader<Group> {
     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(data: ArrayBuffer): Group;
 }

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

@@ -4,16 +4,8 @@ export class USDAParser {
     parse(text: string): object;
 }
 
-export class USDZLoader extends Loader {
+export class USDZLoader extends Loader<Mesh> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (usdz: Mesh) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Mesh>;
-
     parse(buffer: ArrayBuffer | string): THREE.Group;
 }

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

@@ -6,16 +6,9 @@ export interface Chunk {
     data: Uint8Array;
 }
 
-export class VOXLoader extends Loader {
+export class VOXLoader extends Loader<Chunk[]> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (chunks: Chunk[]) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Chunk[]>;
     parse(data: ArrayBuffer): object[];
 }
 

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

@@ -1,14 +1,7 @@
 import { Scene, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class VRMLLoader extends Loader {
+export class VRMLLoader extends Loader<Scene> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (scene: Scene) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<Scene>;
     parse(data: string, path: string): Scene;
 }

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

@@ -1,14 +1,7 @@
 import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class VTKLoader extends Loader {
+export class VTKLoader extends Loader<BufferGeometry> {
     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 | string, path: string): BufferGeometry;
 }

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

@@ -1,14 +1,7 @@
 import { BufferGeometry, Loader, LoadingManager } from '../../../src/Three.js';
 
-export class XYZLoader extends Loader {
+export class XYZLoader extends Loader<BufferGeometry> {
     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: string, onLoad: (geometry: BufferGeometry) => void): object;
 }

three/examples/jsm/nodes/loaders/NodeLoader.d.ts

@@ -5,17 +5,9 @@ export interface NodeLoaderResult {
     [hash: string]: Node;
 }
 
-export default class NodeLoader extends Loader {
+export default class NodeLoader extends Loader<NodeLoaderResult> {
     constructor(manager?: LoadingManager);
 
-    load(
-        url: string,
-        onLoad: (gltf: NodeLoaderResult) => void,
-        onProgress?: (event: ProgressEvent) => void,
-        onError?: (event: ErrorEvent) => void,
-    ): void;
-    loadAsync(url: string, onProgress?: (event: ProgressEvent) => void): Promise<NodeLoaderResult>;
-
     parseNodes(json: AnyJson): NodeLoaderResult;
     parse(json: AnyJson): Node;
     setTextures(textures: { [key: string]: Texture }): this;

three/examples/jsm/postprocessing/FilmPass.d.ts

@@ -3,7 +3,7 @@ import { ShaderMaterial } from '../../../src/Three.js';
 import { Pass, FullScreenQuad } from './Pass.js';
 
 export class FilmPass extends Pass {
-    constructor(noiseIntensity?: number, scanlinesIntensity?: number, scanlinesCount?: number, grayscale?: boolean);
+    constructor(intensity?: number, grayscale?: boolean);
     uniforms: object;
     material: ShaderMaterial;
     fsQuad: FullScreenQuad;

three/examples/jsm/postprocessing/RenderPass.d.ts

@@ -1,13 +1,23 @@
 import { Scene, Camera, Material, Color } from '../../../src/Three.js';
 
-import { Pass, FullScreenQuad } from './Pass.js';
+import { Pass } from './Pass.js';
 
 export class RenderPass extends Pass {
-    constructor(scene: Scene, camera: Camera, overrideMaterial?: Material, clearColor?: Color, clearAlpha?: number);
+    constructor(
+        scene: Scene,
+        camera: Camera,
+        overrideMaterial?: Material | null,
+        clearColor?: Color | null,
+        clearAlpha?: number | null,
+    );
+
     scene: Scene;
     camera: Camera;
-    overrideMaterial: Material;
-    clearColor: Color;
-    clearAlpha: number;
+
+    overrideMaterial: Material | null;
+
+    clearColor: Color | null;
+    clearAlpha: number | null;
+
     clearDepth: boolean;
 }

three/examples/jsm/postprocessing/SAOPass.d.ts

@@ -2,7 +2,6 @@ import {
     Scene,
     Camera,
     Material,
-    MeshDepthMaterial,
     MeshNormalMaterial,
     ShaderMaterial,
     Color,
@@ -15,10 +14,8 @@ import {
 import { Pass, FullScreenQuad } from './Pass.js';
 
 export enum OUTPUT {
-    Beauty,
     Default,
     SAO,
-    Depth,
     Normal,
 }
 
@@ -36,27 +33,21 @@ export interface SAOPassParams {
 }
 
 export class SAOPass extends Pass {
-    constructor(scene: Scene, camera: Camera, depthTexture?: boolean, useNormals?: boolean, resolution?: Vector2);
+    constructor(scene: Scene, camera: Camera, resolution?: Vector2);
     scene: Scene;
     camera: Camera;
-    supportsDepthTextureExtension: boolean;
-    supportsNormalTexture: boolean;
     originalClearColor: Color;
     oldClearColor: Color;
     oldClearAlpha: number;
     resolution: Vector2;
     saoRenderTarget: WebGLRenderTarget;
     blurIntermediateRenderTarget: WebGLRenderTarget;
-    beautyRenderTarget: WebGLRenderTarget;
     normalRenderTarget: WebGLRenderTarget;
-    depthRenderTarget: WebGLRenderTarget;
-    depthMaterial: MeshDepthMaterial;
     normalMaterial: MeshNormalMaterial;
     saoMaterial: ShaderMaterial;
     vBlurMaterial: ShaderMaterial;
     hBlurMaterial: ShaderMaterial;
     materialCopy: ShaderMaterial;
-    depthCopy: ShaderMaterial;
     fsQuad: FullScreenQuad;
     params: SAOPassParams;
 

three/examples/jsm/postprocessing/SSAOPass.d.ts

@@ -18,26 +18,23 @@ export enum SSAOPassOUTPUT {
     Default,
     SSAO,
     Blur,
-    Beauty,
     Depth,
     Normal,
 }
 
 export class SSAOPass extends Pass {
-    constructor(scene: Scene, camera: Camera, width?: number, height?: number);
+    constructor(scene: Scene, camera: Camera, width?: number, height?: number, kernelSize?: number);
     scene: Scene;
     camera: Camera;
     width: number;
     height: boolean;
     clear: boolean;
     kernelRadius: number;
-    kernelSize: number;
     kernel: Vector3[];
     noiseTexture: DataTexture;
     output: SSAOPassOUTPUT;
     minDistance: number;
     maxDistance: number;
-    beautyRenderTarget: WebGLRenderTarget;
     normalRenderTarget: WebGLRenderTarget;
     ssaoRenderTarget: WebGLRenderTarget;
     blurRenderTarget: WebGLRenderTarget;
@@ -52,7 +49,7 @@ export class SSAOPass extends Pass {
     static OUTPUT: typeof SSAOPassOUTPUT;
 
     dipose(): void;
-    generateSampleKernel(): Vector3[];
+    generateSampleKernel(kernelSize: number): Vector3[];
     generateRandomKernelRotations(): void;
     renderPass(
         renderer: WebGLRenderer,

three/examples/jsm/shaders/FilmShader.d.ts

@@ -4,9 +4,7 @@ export const FilmShader: {
     uniforms: {
         tDiffuse: IUniform;
         time: IUniform;
-        nIntensity: IUniform;
-        sIntensity: IUniform;
-        sCount: IUniform;
+        intensity: IUniform;
         grayscale: IUniform;
     };
     vertexShader: string;

three/examples/jsm/shaders/SAOShader.d.ts

@@ -4,9 +4,7 @@ export const SAOShader: {
     defines: {
         NUM_SAMPLES: number;
         NUM_RINGS: number;
-        NORMAL_TEXTURE: number;
         DIFFUSE_TEXTURE: number;
-        DEPTH_PACKING: number;
         PERSPECTIVE_CAMERA: number;
     };
     uniforms: {

three/examples/jsm/shaders/SSAOShader.d.ts

@@ -6,7 +6,6 @@ export const SSAOShader: {
         KERNEL_SIZE: number;
     };
     uniforms: {
-        tDiffuse: IUniform;
         tNormal: IUniform;
         tDepth: IUniform;
         tNoise: IUniform;

three/examples/jsm/webxr/XREstimatedLight.d.ts

@@ -1,4 +1,4 @@
-import { DirectionalLight, Group, LightProbe, Texture, WebGLRenderer } from '../../../src/Three.js';
+import { DirectionalLight, Group, LightProbe, Texture, WebGLRenderer, Object3DEventMap } from '../../../src/Three.js';
 
 export class SessionLightProbe {
     xrLight: XREstimatedLight;
@@ -23,7 +23,12 @@ export class SessionLightProbe {
     dispose: () => void;
 }
 
-export class XREstimatedLight extends Group {
+export interface XREstimatedLightEventMap extends Object3DEventMap {
+    estimationstart: {};
+    estimationend: {};
+}
+
+export class XREstimatedLight extends Group<XREstimatedLightEventMap> {
     lightProbe: LightProbe;
     directionalLight: DirectionalLight;
     environment: Texture;

three/index.d.ts

@@ -1,9 +1,8 @@
-// Type definitions for three 0.155
+// Type definitions for three 0.156
 // Project: https://threejs.org/
 // Definitions by: Josh Ellis <https://github.com/joshuaellis>
 //                 Nathan Bierema <https://github.com/Methuselah96>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// Minimum TypeScript Version: 4.4
 
 // To update three.js type definition, please make changes to the repository at:
 // https://github.com/three-types/three-ts-types.

three/package.json

@@ -1,6 +1,6 @@
 {
     "name": "@types/three",
-    "version": "0.155.1",
+    "version": "0.156.0",
     "description": "TypeScript definitions for three",
     "homepage": "https://github.com/DefinitelyTyped/DefinitelyTyped/tree/master/types/three",
     "license": "MIT",
@@ -25,15 +25,13 @@
     },
     "scripts": {},
     "dependencies": {
-        "@tweenjs/tween.js": "~18.6.4",
         "@types/stats.js": "*",
         "@types/webxr": "*",
-        "fflate": "~0.6.9",
-        "lil-gui": "~0.17.0",
+        "fflate": "~0.6.10",
         "meshoptimizer": "~0.18.1"
     },
-    "typesPublisherContentHash": "e95ca925c70bfdbc8f8ae36c5d54552fba9db84a9fa72acb7f66e8234540c623",
-    "typeScriptVersion": "4.4",
+    "typesPublisherContentHash": "c7fc65a1fef93103d5e9db486206657217d03ee8c514a14ecd05aaa469b45a0c",
+    "typeScriptVersion": "4.3",
     "exports": {
         ".": {
             "import": "./build/three.module.js",

three/src/Three.d.ts

@@ -234,3 +234,7 @@ export * from './textures/DepthTexture.js';
 export * from './textures/FramebufferTexture.js';
 export * from './textures/Source.js';
 export * from './textures/Texture.js';
+/**
+ * Utils
+ */
+export { createCanvasElement } from './utils.js';

three/src/animation/AnimationMixer.d.ts

@@ -5,7 +5,12 @@ import { EventDispatcher } from './../core/EventDispatcher.js';
 import { Object3D } from '../core/Object3D.js';
 import { AnimationObjectGroup } from './AnimationObjectGroup.js';
 
-export class AnimationMixer extends EventDispatcher {
+export interface AnimationMixerEventMap {
+    loop: { action: AnimationAction; loopDelta: number };
+    finished: { action: AnimationAction; direction: number };
+}
+
+export class AnimationMixer extends EventDispatcher<AnimationMixerEventMap> {
     constructor(root: Object3D | AnimationObjectGroup);
 
     /**

three/src/constants.d.ts

@@ -596,6 +596,8 @@ export const RGBA_ASTC_12x12_Format: 37821;
  * @remarks Require support for the _EXT_texture_compression_bptc_ WebGL extension.
  */
 export const RGBA_BPTC_Format: 36492;
+export const RGB_BPTC_SIGNED_Format = 36494;
+export const RGB_BPTC_UNSIGNED_Format = 36495;
 
 // RGTC compressed texture formats
 export const RED_RGTC1_Format: 36283;
@@ -634,6 +636,8 @@ export type CompressedPixelFormat =
     | typeof RGBA_ASTC_12x10_Format
     | typeof RGBA_ASTC_12x12_Format
     | typeof RGBA_BPTC_Format
+    | typeof RGB_BPTC_SIGNED_Format
+    | typeof RGB_BPTC_UNSIGNED_Format
     | typeof RED_RGTC1_Format
     | typeof SIGNED_RED_RGTC1_Format
     | typeof RED_GREEN_RGTC2_Format
@@ -712,11 +716,13 @@ export const NoColorSpace: '';
 export const SRGBColorSpace: 'srgb';
 export const LinearSRGBColorSpace: 'srgb-linear';
 export const DisplayP3ColorSpace: 'display-p3';
+export const LinearDisplayP3ColorSpace = 'display-p3-linear';
 export type ColorSpace =
     | typeof NoColorSpace
     | typeof SRGBColorSpace
     | typeof LinearSRGBColorSpace
-    | typeof DisplayP3ColorSpace;
+    | typeof DisplayP3ColorSpace
+    | typeof LinearDisplayP3ColorSpace;
 
 // Stencil Op types
 export const ZeroStencilOp: 0;

three/src/core/BufferGeometry.d.ts

@@ -75,7 +75,7 @@ export type NormalOrGLBufferAttributes = Record<
  */
 export class BufferGeometry<
     Attributes extends NormalOrGLBufferAttributes = NormalBufferAttributes,
-> extends EventDispatcher {
+> extends EventDispatcher<{ dispose: {} }> {
     /**
      * This creates a new {@link THREE.BufferGeometry | BufferGeometry} object.
      */

three/src/core/EventDispatcher.d.ts

@@ -1,15 +1,21 @@
-export interface BaseEvent {
-    type: string;
+/**
+ * The minimal basic Event that can be dispatched by a {@link EventDispatcher<>}.
+ */
+export interface BaseEvent<TEventType extends string = string> {
+    readonly type: TEventType;
 }
 
 /**
- * Event object.
+ * The minimal expected contract of a fired Event that was dispatched by a {@link EventDispatcher<>}.
  */
-export interface Event extends BaseEvent {
-    target?: any;
-    [attachment: string]: any;
+export interface Event<TEventType extends string = string, TTarget = unknown> {
+    readonly type: TEventType;
+    readonly target: TTarget;
 }
-export type EventListener<E, T, U> = (event: E & { type: T } & { target: U }) => void;
+
+export type EventListener<TEventData, TEventType extends string, TTarget> = (
+    event: TEventData & Event<TEventType, TTarget>,
+) => void;
 
 /**
  * JavaScript events for custom objects
@@ -32,7 +38,7 @@ export type EventListener<E, T, U> = (event: E & { type: T } & { target: U }) =>
  * @see {@link https://threejs.org/docs/index.html#api/en/core/EventDispatcher | Official Documentation}
  * @see {@link https://github.com/mrdoob/three.js/blob/master/src/core/EventDispatcher.js | Source}
  */
-export class EventDispatcher<E extends BaseEvent = Event> {
+export class EventDispatcher<TEventMap extends {} = {}> {
     /**
      * Creates {@link THREE.EventDispatcher | EventDispatcher} object.
      */
@@ -43,25 +49,37 @@ export class EventDispatcher<E extends BaseEvent = Event> {
      * @param type The type of event to listen to.
      * @param listener The function that gets called when the event is fired.
      */
-    addEventListener<T extends E['type']>(type: T, listener: EventListener<E, T, this>): void;
+    addEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void;
+    addEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Checks if listener is added to an event type.
      * @param type The type of event to listen to.
      * @param listener The function that gets called when the event is fired.
      */
-    hasEventListener<T extends E['type']>(type: T, listener: EventListener<E, T, this>): boolean;
+    hasEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): boolean;
+    hasEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): boolean;
 
     /**
      * Removes a listener from an event type.
      * @param type The type of the listener that gets removed.
      * @param listener The listener function that gets removed.
      */
-    removeEventListener<T extends E['type']>(type: T, listener: EventListener<E, T, this>): void;
+    removeEventListener<T extends Extract<keyof TEventMap, string>>(
+        type: T,
+        listener: EventListener<TEventMap[T], T, this>,
+    ): void;
+    removeEventListener<T extends string>(type: T, listener: EventListener<{}, T, this>): void;
 
     /**
      * Fire an event type.
      * @param event The event that gets fired.
      */
-    dispatchEvent(event: E): void;
+    dispatchEvent<T extends Extract<keyof TEventMap, string>>(event: BaseEvent<T> & TEventMap[T]): void;
 }