DefinitelyTyped · typescript-bot · Oct 31, 2024 · Jun 27, 2024 · Aug 4, 2024 · Aug 4, 2024
diff --git a/types/imap/index.d.ts b/types/imap/index.d.ts
@@ -267,18 +267,6 @@ declare namespace Connection {
 declare class Connection extends EventEmitter implements Connection.MessageFunctions {
     constructor(config: Connection.Config);
 
-    // from NodeJS.EventEmitter
-    addListener(event: string, listener: Function): this;
-    on(event: string, listener: Function): this;
-    once(event: string, listener: Function): this;
-    removeListener(event: string, listener: Function): this;
-    removeAllListeners(event?: string): this;
-    setMaxListeners(n: number): this;
-    getMaxListeners(): number;
-    listeners(event: string): Function[];
-    emit(event: string, ...args: any[]): boolean;
-    listenerCount(type: string): number;
-
     // from MessageFunctions
     /** Searches the currently open mailbox for messages using given criteria. criteria is a list describing what you want to find. For criteria types that require arguments, use an array instead of just the string criteria type name (e.g. ['FROM', 'foo@bar.com']). Prefix criteria types with an "!" to negate. */
     search(criteria: any[], callback: (error: Error, uids: number[]) => void): void;

diff --git a/types/jake/index.d.ts b/types/jake/index.d.ts
@@ -241,16 +241,6 @@ declare global {
              */
             reenable(): void;
 
-            addListener(event: string, listener: Function): this;
-            on(event: string, listener: Function): this;
-            once(event: string, listener: Function): this;
-            removeListener(event: string, listener: Function): this;
-            removeAllListeners(event?: string): this;
-            setMaxListeners(n: number): this;
-            getMaxListeners(): number;
-            listeners(event: string): Function[];
-            emit(event: string, ...args: any[]): boolean;
-            listenerCount(type: string): number;
             complete(value?: any): void;
             value: any;
 

diff --git a/types/newman/newman-tests.ts b/types/newman/newman-tests.ts
@@ -23,7 +23,7 @@ const workingDir = "path/to/working/directory";
 const insecureFileRead = true;
 const requestAgent = new http.Agent();
 
-// $ExpectType EventEmitter<DefaultEventMap>
+// $ExpectType EventEmitter<{}>
 run(
     {
         collection,

diff --git a/types/node-red/node-red-tests.ts b/types/node-red/node-red-tests.ts
@@ -23,7 +23,7 @@ async function REDTests() {
     // $ExpectType Util
     RED.util;
 
-    // $ExpectType EventEmitter<DefaultEventMap>
+    // $ExpectType EventEmitter<{}>
     RED.events;
 
     // $ExpectType Hooks

@@ -31,7 +31,7 @@ declare const any: any;
     result = emitter.getMaxListeners();
     result = emitter.listenerCount(event);
 
-    const handler: Function = () => {};
+    const handler = () => {};
     result = emitter.listenerCount(event, handler);
 }
 
@@ -141,7 +141,7 @@ async function testEventTarget() {
     captureRejectionSymbol2 = events.captureRejectionSymbol;
 
     const emitter = new events.EventEmitter();
-    emitter[events.captureRejectionSymbol] = (err: Error, name: string, ...args: any[]) => {};
+    emitter[events.captureRejectionSymbol] = (err: Error, name: string | symbol, ...args: any[]) => {};
 }
 
 {
@@ -193,16 +193,16 @@ async function testEventTarget() {
 
 {
     class MyEmitter extends events.EventEmitter {
-        addListener(event: string, listener: () => void): this {
+        addListener(event: string | symbol, listener: () => void): this {
             return this;
         }
-        listeners(event: string): Array<() => void> {
+        listeners(event: string | symbol): Array<() => void> {
             return [];
         }
-        emit(event: string, ...args: any[]): boolean {
+        emit(event: string | symbol, ...args: any[]): boolean {
             return true;
         }
-        listenerCount(type: string): number {
+        listenerCount(type: string | symbol): number {
             return 0;
         }
     }

@@ -110,13 +110,17 @@ declare const event5: "event5";
 }
 
 {
-    let result: Promise<number[]>;
-
-    result = events.once(emitter, event1);
-    result = events.once(emitter, event2);
-    result = events.once(emitter, event3);
-    result = events.once(emitter, event4);
-    result = events.once(emitter, event5);
+    let result1: Promise<T["event1"]>;
+    let result2: Promise<T["event2"]>;
+    let result3: Promise<T["event3"]>;
+    let result4: Promise<T["event4"]>;
+    let result5: Promise<T["event5"]>;
+
+    result1 = events.once(emitter, event1);
+    result2 = events.once(emitter, event2);
+    result3 = events.once(emitter, event3);
+    result4 = events.once(emitter, event4);
+    result5 = events.once(emitter, event5);
 
     emitter.emit("event1", "hello", 42);
     emitter.emit("event2", true);
@@ -146,7 +150,7 @@ declare const event5: "event5";
 }
 
 {
-    let result: Array<keyof T>;
+    let result: Array<keyof T | keyof events.EventEmitterBuiltInEventMap>;
 
     result = emitter.eventNames();
 }
@@ -157,12 +161,12 @@ declare const event5: "event5";
         )
         : never;
 
-    function on1<K>(event: K, listener: Listener<K>): void {
+    function on1<K extends keyof T>(event: K, listener: Listener<K>): void {
         emitter.on(event, listener);
     }
 
     // eslint-disable-next-line @definitelytyped/no-unnecessary-generics
-    function on2<K>(...args: Parameters<typeof emitter.on<K>>): void {
+    function on2<K extends keyof T>(...args: Parameters<typeof emitter.on<K>>): void {
         emitter.on(...args);
     }
 
@@ -204,7 +208,6 @@ declare const event5: "event5";
     emitter.emit("abc", "hello", 123);
     // @ts-expect-error
     emitter.emit("abc", 123, false);
-    // @ts-expect-error
     emitter.emit("def", "hello", 123);
 }
 
@@ -226,7 +229,6 @@ declare const event5: "event5";
     emitter.emit(s1, "hello", 123);
     // @ts-expect-error
     emitter.emit(s1, 123, false);
-    // @ts-expect-error
     emitter.emit(s2, "hello", 123);
 }
 
@@ -244,6 +246,71 @@ declare const event5: "event5";
     emitter.emit(789, 123, false);
     // @ts-expect-error
     emitter.emit(s1, "hello", false);
-    // @ts-expect-error
     emitter.emit(s2, "hello", false);
 }
+
+{
+    const promise1: Promise<[string, number]> = events.once(new events.EventEmitter<T>(), "event1");
+    const promise2: Promise<[boolean]> = events.once(new events.EventEmitter<T>(), "event2");
+    const promise3: Promise<[]> = events.once(new events.EventEmitter<T>(), "event3");
+    const promise4: Promise<string[]> = events.once(new events.EventEmitter<T>(), "event4");
+    const promise5: Promise<unknown[]> = events.once(new events.EventEmitter<T>(), "event5");
+    // @ts-expect-error
+    const promise6: Promise<[string, string]> = events.once(new events.EventEmitter<T>(), "event1");
+    const promise7: Promise<any[]> = events.once(new events.EventEmitter<T>(), "event");
+
+    const iterable1: NodeJS.AsyncIterator<[string, number]> = events.on(new events.EventEmitter<T>(), "event1");
+    const iterable2: NodeJS.AsyncIterator<[boolean]> = events.on(new events.EventEmitter<T>(), "event2");
+    const iterable3: NodeJS.AsyncIterator<[]> = events.on(new events.EventEmitter<T>(), "event3");
+    const iterable4: NodeJS.AsyncIterator<string[]> = events.on(new events.EventEmitter<T>(), "event4");
+    const iterable5: NodeJS.AsyncIterator<unknown[]> = events.on(new events.EventEmitter<T>(), "event5");
+    // @ts-expect-error
+    const iterable6: NodeJS.AsyncIterator<[string, string]> = events.on(new events.EventEmitter<T>(), "event1");
+    const iterable7: NodeJS.AsyncIterator<any[]> = events.on(new events.EventEmitter<T>(), "event");
+}
+
+{
+    function acceptsEventEmitterInterface(eventEmitter: NodeJS.EventEmitter) {
+    }
+
+    function acceptsEventEmitterClass(eventEmitter: events.EventEmitter) {
+    }
+
+    acceptsEventEmitterInterface(emitter);
+    acceptsEventEmitterClass(emitter);
+}
+
+{
+    class Extended extends events.EventEmitter<T> {}
+
+    class DoubleExtension extends Extended {}
+
+    const extended = new Extended();
+    const doubleExtended = new DoubleExtension();
+
+    events.on(extended, "event1"); // $ExpectType AsyncIterator<[string, number], any, any>
+    events.once(extended, "event1"); // $ExpectType Promise<[string, number]>
+
+    events.on(extended, "unknown"); // $ExpectType AsyncIterator<any[], any, any>
+    events.once(extended, "unknown"); // $ExpectType Promise<any[]>
+
+    events.on(doubleExtended, "event1"); // $ExpectType AsyncIterator<[string, number], any, any>
+    events.once(doubleExtended, "event1"); // $ExpectType Promise<[string, number]>
+
+    events.on(doubleExtended, "unknown"); // $ExpectType AsyncIterator<any[], any, any>
+    events.once(doubleExtended, "unknown"); // $ExpectType Promise<any[]>
+
+    extended.addListener(event1, (a: string, b: number | boolean): number => 1);
+    doubleExtended.addListener(event1, (a: string, b: number | boolean): number => 1);
+    // @ts-expect-error
+    extended.addListener(event1, (a: string, b: boolean): number => 1);
+    // @ts-expect-error
+    doubleExtended.addListener(event1, (a: string, b: boolean): number => 1);
+
+    extended.emit("event1", "hello", 42);
+    doubleExtended.emit("event1", "hello", 42);
+    // @ts-expect-error
+    extended.emit("event1", 123);
+    // @ts-expect-error
+    doubleExtended.emit("event1", 123);
+}