@rio-cloud/cdk-v2-constructs 8.2.0-alpha.0 → 8.2.1-alpha.0

package/node_modules/@types/node/events.d.ts

@@ -32,67 +32,58 @@
  * });
  * myEmitter.emit('event');
  * ```
- * @see [source](https://github.com/nodejs/node/blob/v20.2.0/lib/events.js)
+ * @see [source](https://github.com/nodejs/node/blob/v24.x/lib/events.js)
  */
 declare module "events" {
     import { AsyncResource, AsyncResourceOptions } from "node:async_hooks";
-    // NOTE: This class is in the docs but is **not actually exported** by Node.
-    // If https://github.com/nodejs/node/issues/39903 gets resolved and Node
-    // actually starts exporting the class, uncomment below.
-    // import { EventListener, EventListenerObject } from '__dom-events';
-    // /** The NodeEventTarget is a Node.js-specific extension to EventTarget that emulates a subset of the EventEmitter API. */
-    // interface NodeEventTarget extends EventTarget {
-    //     /**
-    //      * Node.js-specific extension to the `EventTarget` class that emulates the equivalent `EventEmitter` API.
-    //      * The only difference between `addListener()` and `addEventListener()` is that addListener() will return a reference to the EventTarget.
-    //      */
-    //     addListener(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
-    //     /** Node.js-specific extension to the `EventTarget` class that returns an array of event `type` names for which event listeners are registered. */
-    //     eventNames(): string[];
-    //     /** Node.js-specific extension to the `EventTarget` class that returns the number of event listeners registered for the `type`. */
-    //     listenerCount(type: string): number;
-    //     /** Node.js-specific alias for `eventTarget.removeListener()`. */
-    //     off(type: string, listener: EventListener | EventListenerObject): this;
-    //     /** Node.js-specific alias for `eventTarget.addListener()`. */
-    //     on(type: string, listener: EventListener | EventListenerObject, options?: { once: boolean }): this;
-    //     /** Node.js-specific extension to the `EventTarget` class that adds a `once` listener for the given event `type`. This is equivalent to calling `on` with the `once` option set to `true`. */
-    //     once(type: string, listener: EventListener | EventListenerObject): this;
-    //     /**
-    //      * Node.js-specific extension to the `EventTarget` class.
-    //      * If `type` is specified, removes all registered listeners for `type`,
-    //      * otherwise removes all registered listeners.
-    //      */
-    //     removeAllListeners(type: string): this;
-    //     /**
-    //      * Node.js-specific extension to the `EventTarget` class that removes the listener for the given `type`.
-    //      * The only difference between `removeListener()` and `removeEventListener()` is that `removeListener()` will return a reference to the `EventTarget`.
-    //      */
-    //     removeListener(type: string, listener: EventListener | EventListenerObject): this;
-    // }
     interface EventEmitterOptions {
         /**
          * Enables automatic capturing of promise rejection.
          */
         captureRejections?: boolean | undefined;
     }
-    // Any EventTarget with a Node-style `once` function
-    interface _NodeEventTarget {
-        once(eventName: string | symbol, listener: (...args: any[]) => void): this;
-    }
-    // Any EventTarget with a DOM-style `addEventListener`
-    interface _DOMEventTarget {
-        addEventListener(
-            eventName: string,
-            listener: (...args: any[]) => void,
-            opts?: {
-                once: boolean;
-            },
-        ): any;
-    }
     interface StaticEventEmitterOptions {
+        /**
+         * Can be used to cancel awaiting events.
+         */
         signal?: AbortSignal | undefined;
     }
-    interface EventEmitter extends NodeJS.EventEmitter {}
+    interface StaticEventEmitterIteratorOptions extends StaticEventEmitterOptions {
+        /**
+         * Names of events that will end the iteration.
+         */
+        close?: string[] | undefined;
+        /**
+         * The high watermark. The emitter is paused every time the size of events being buffered is higher than it.
+         * Supported only on emitters implementing `pause()` and `resume()` methods.
+         * @default Number.MAX_SAFE_INTEGER
+         */
+        highWaterMark?: number | undefined;
+        /**
+         * The low watermark. The emitter is resumed every time the size of events being buffered is lower than it.
+         * Supported only on emitters implementing `pause()` and `resume()` methods.
+         * @default 1
+         */
+        lowWaterMark?: number | undefined;
+    }
+    interface EventEmitter<T extends EventMap<T> = DefaultEventMap> extends NodeJS.EventEmitter<T> {}
+    type EventMap<T> = Record<keyof T, any[]> | DefaultEventMap;
+    type DefaultEventMap = [never];
+    type AnyRest = [...args: any[]];
+    type Args<K, T> = T extends DefaultEventMap ? AnyRest : (
+        K extends keyof T ? T[K] : never
+    );
+    type Key<K, T> = T extends DefaultEventMap ? string | symbol : K | keyof T;
+    type Key2<K, T> = T extends DefaultEventMap ? string | symbol : K & keyof T;
+    type Listener<K, T, F> = T extends DefaultEventMap ? F : (
+        K extends keyof T ? (
+                T[K] extends unknown[] ? (...args: T[K]) => void : never
+            )
+            : never
+    );
+    type Listener1<K, T> = Listener<K, T, (...args: any[]) => void>;
+    type Listener2<K, T> = Listener<K, T, Function>;
+
     /**
      * The `EventEmitter` class is defined and exposed by the `node:events` module:
      *
@@ -106,10 +97,10 @@ declare module "events" {
      * It supports the following option:
      * @since v0.1.26
      */
-    class EventEmitter {
+    class EventEmitter<T extends EventMap<T> = DefaultEventMap> {
         constructor(options?: EventEmitterOptions);
 
-        [EventEmitter.captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
+        [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
 
         /**
          * Creates a `Promise` that is fulfilled when the `EventEmitter` emits the given
@@ -145,7 +136,7 @@ declare module "events" {
          * }
          * ```
          *
-         * The special handling of the `'error'` event is only used when `events.once()`is used to wait for another event. If `events.once()` is used to wait for the
+         * The special handling of the `'error'` event is only used when `events.once()` is used to wait for another event. If `events.once()` is used to wait for the
          * '`error'` event itself, then it is treated as any other kind of event without
          * special handling:
          *
@@ -191,11 +182,11 @@ declare module "events" {
          * @since v11.13.0, v10.16.0
          */
         static once(
-            emitter: _NodeEventTarget,
+            emitter: NodeJS.EventEmitter,
             eventName: string | symbol,
             options?: StaticEventEmitterOptions,
         ): Promise<any[]>;
-        static once(emitter: _DOMEventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
+        static once(emitter: EventTarget, eventName: string, options?: StaticEventEmitterOptions): Promise<any[]>;
         /**
          * ```js
          * import { on, EventEmitter } from 'node:events';
@@ -251,17 +242,43 @@ declare module "events" {
          *
          * process.nextTick(() => ac.abort());
          * ```
+         *
+         * Use the `close` option to specify an array of event names that will end the iteration:
+         *
+         * ```js
+         * import { on, EventEmitter } from 'node:events';
+         * import process from 'node:process';
+         *
+         * const ee = new EventEmitter();
+         *
+         * // Emit later on
+         * process.nextTick(() => {
+         *   ee.emit('foo', 'bar');
+         *   ee.emit('foo', 42);
+         *   ee.emit('close');
+         * });
+         *
+         * for await (const event of on(ee, 'foo', { close: ['close'] })) {
+         *   console.log(event); // prints ['bar'] [42]
+         * }
+         * // the loop will exit after 'close' is emitted
+         * console.log('done'); // prints 'done'
+         * ```
          * @since v13.6.0, v12.16.0
-         * @param eventName The name of the event being listened for
-         * @return that iterates `eventName` events emitted by the `emitter`
+         * @return An `AsyncIterator` that iterates `eventName` events emitted by the `emitter`
          */
         static on(
             emitter: NodeJS.EventEmitter,
+            eventName: string | symbol,
+            options?: StaticEventEmitterIteratorOptions,
+        ): NodeJS.AsyncIterator<any[]>;
+        static on(
+            emitter: EventTarget,
             eventName: string,
-            options?: StaticEventEmitterOptions,
-        ): AsyncIterableIterator<any>;
+            options?: StaticEventEmitterIteratorOptions,
+        ): NodeJS.AsyncIterator<any[]>;
         /**
-         * A class method that returns the number of listeners for the given `eventName`registered on the given `emitter`.
+         * A class method that returns the number of listeners for the given `eventName` registered on the given `emitter`.
          *
          * ```js
          * import { EventEmitter, listenerCount } from 'node:events';
@@ -305,7 +322,7 @@ declare module "events" {
          * ```
          * @since v15.2.0, v14.17.0
          */
-        static getEventListeners(emitter: _DOMEventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
+        static getEventListeners(emitter: EventTarget | NodeJS.EventEmitter, name: string | symbol): Function[];
         /**
          * Returns the currently set max amount of listeners.
          *
@@ -334,7 +351,7 @@ declare module "events" {
          * ```
          * @since v19.9.0
          */
-        static getMaxListeners(emitter: _DOMEventTarget | NodeJS.EventEmitter): number;
+        static getMaxListeners(emitter: EventTarget | NodeJS.EventEmitter): number;
         /**
          * ```js
          * import { setMaxListeners, EventEmitter } from 'node:events';
@@ -346,10 +363,10 @@ declare module "events" {
          * ```
          * @since v15.4.0
          * @param n A non-negative number. The maximum number of listeners per `EventTarget` event.
-         * @param eventsTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
+         * @param eventTargets Zero or more {EventTarget} or {EventEmitter} instances. If none are specified, `n` is set as the default max for all newly created {EventTarget} and {EventEmitter}
          * objects.
          */
-        static setMaxListeners(n?: number, ...eventTargets: Array<_DOMEventTarget | NodeJS.EventEmitter>): void;
+        static setMaxListeners(n?: number, ...eventTargets: Array<EventTarget | NodeJS.EventEmitter>): void;
         /**
          * Listens once to the `abort` event on the provided `signal`.
          *
@@ -381,14 +398,13 @@ declare module "events" {
          * }
          * ```
          * @since v20.5.0
-         * @experimental
          * @return Disposable that removes the `abort` listener.
          */
         static addAbortListener(signal: AbortSignal, resource: (event: Event) => void): Disposable;
         /**
-         * This symbol shall be used to install a listener for only monitoring `'error'`events. Listeners installed using this symbol are called before the regular`'error'` listeners are called.
+         * This symbol shall be used to install a listener for only monitoring `'error'` events. Listeners installed using this symbol are called before the regular `'error'` listeners are called.
          *
-         * Installing a listener using this symbol does not change the behavior once an`'error'` event is emitted. Therefore, the process will still crash if no
+         * Installing a listener using this symbol does not change the behavior once an `'error'` event is emitted. Therefore, the process will still crash if no
          * regular `'error'` listener is installed.
          * @since v13.6.0, v12.17.0
          */
@@ -411,16 +427,18 @@ declare module "events" {
          * By default, a maximum of `10` listeners can be registered for any single
          * event. This limit can be changed for individual `EventEmitter` instances
          * using the `emitter.setMaxListeners(n)` method. To change the default
-         * for _all_`EventEmitter` instances, the `events.defaultMaxListeners`property can be used. If this value is not a positive number, a `RangeError`is thrown.
+         * for _all_`EventEmitter` instances, the `events.defaultMaxListeners` property
+         * can be used. If this value is not a positive number, a `RangeError` is thrown.
          *
          * Take caution when setting the `events.defaultMaxListeners` because the
-         * change affects _all_`EventEmitter` instances, including those created before
+         * change affects _all_ `EventEmitter` instances, including those created before
          * the change is made. However, calling `emitter.setMaxListeners(n)` still has
          * precedence over `events.defaultMaxListeners`.
          *
          * This is not a hard limit. The `EventEmitter` instance will allow
          * more listeners to be added but will output a trace warning to stderr indicating
-         * that a "possible EventEmitter memory leak" has been detected. For any single`EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()`methods can be used to
+         * that a "possible EventEmitter memory leak" has been detected. For any single
+         * `EventEmitter`, the `emitter.getMaxListeners()` and `emitter.setMaxListeners()` methods can be used to
          * temporarily avoid this warning:
          *
          * ```js
@@ -466,17 +484,45 @@ declare module "events" {
              * directly rather than as a child class.
              * @default new.target.name if instantiated as a child class.
              */
-            name?: string;
+            name?: string | undefined;
         }
 
         /**
-         * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that require
-         * manual async tracking. Specifically, all events emitted by instances of
-         * `EventEmitterAsyncResource` will run within its async context.
+         * Integrates `EventEmitter` with `AsyncResource` for `EventEmitter`s that
+         * require manual async tracking. Specifically, all events emitted by instances
+         * of `events.EventEmitterAsyncResource` will run within its `async context`.
+         *
+         * ```js
+         * import { EventEmitterAsyncResource, EventEmitter } from 'node:events';
+         * import { notStrictEqual, strictEqual } from 'node:assert';
+         * import { executionAsyncId, triggerAsyncId } from 'node:async_hooks';
+         *
+         * // Async tracking tooling will identify this as 'Q'.
+         * const ee1 = new EventEmitterAsyncResource({ name: 'Q' });
+         *
+         * // 'foo' listeners will run in the EventEmitters async context.
+         * ee1.on('foo', () => {
+         *   strictEqual(executionAsyncId(), ee1.asyncId);
+         *   strictEqual(triggerAsyncId(), ee1.triggerAsyncId);
+         * });
          *
-         * The EventEmitterAsyncResource class has the same methods and takes the
-         * same options as EventEmitter and AsyncResource themselves.
-         * @throws if `options.name` is not provided when instantiated directly.
+         * const ee2 = new EventEmitter();
+         *
+         * // 'foo' listeners on ordinary EventEmitters that do not track async
+         * // context, however, run in the same async context as the emit().
+         * ee2.on('foo', () => {
+         *   notStrictEqual(executionAsyncId(), ee2.asyncId);
+         *   notStrictEqual(triggerAsyncId(), ee2.triggerAsyncId);
+         * });
+         *
+         * Promise.resolve().then(() => {
+         *   ee1.emit('foo');
+         *   ee2.emit('foo');
+         * });
+         * ```
+         *
+         * The `EventEmitterAsyncResource` class has the same methods and takes the
+         * same options as `EventEmitter` and `AsyncResource` themselves.
          * @since v17.4.0, v16.14.0
          */
         export class EventEmitterAsyncResource extends EventEmitter {
@@ -485,34 +531,120 @@ declare module "events" {
              */
             constructor(options?: EventEmitterAsyncResourceOptions);
             /**
-             * Call all destroy hooks. This should only ever be called once. An
-             * error will be thrown if it is called more than once. This must be
-             * manually called. If the resource is left to be collected by the GC then
-             * the destroy hooks will never be called.
+             * Call all `destroy` hooks. This should only ever be called once. An error will
+             * be thrown if it is called more than once. This **must** be manually called. If
+             * the resource is left to be collected by the GC then the `destroy` hooks will
+             * never be called.
              */
             emitDestroy(): void;
-            /** The unique asyncId assigned to the resource. */
+            /**
+             * The unique `asyncId` assigned to the resource.
+             */
             readonly asyncId: number;
-            /** The same triggerAsyncId that is passed to the AsyncResource constructor. */
+            /**
+             * The same triggerAsyncId that is passed to the AsyncResource constructor.
+             */
             readonly triggerAsyncId: number;
-            /** The underlying AsyncResource */
+            /**
+             * The returned `AsyncResource` object has an additional `eventEmitter` property
+             * that provides a reference to this `EventEmitterAsyncResource`.
+             */
             readonly asyncResource: EventEmitterReferencingAsyncResource;
         }
+        /**
+         * The `NodeEventTarget` is a Node.js-specific extension to `EventTarget`
+         * that emulates a subset of the `EventEmitter` API.
+         * @since v14.5.0
+         */
+        export interface NodeEventTarget extends EventTarget {
+            /**
+             * Node.js-specific extension to the `EventTarget` class that emulates the
+             * equivalent `EventEmitter` API. The only difference between `addListener()` and
+             * `addEventListener()` is that `addListener()` will return a reference to the
+             * `EventTarget`.
+             * @since v14.5.0
+             */
+            addListener(type: string, listener: (arg: any) => void): this;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that dispatches the
+             * `arg` to the list of handlers for `type`.
+             * @since v15.2.0
+             * @returns `true` if event listeners registered for the `type` exist,
+             * otherwise `false`.
+             */
+            emit(type: string, arg: any): boolean;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that returns an array
+             * of event `type` names for which event listeners are registered.
+             * @since 14.5.0
+             */
+            eventNames(): string[];
+            /**
+             * Node.js-specific extension to the `EventTarget` class that returns the number
+             * of event listeners registered for the `type`.
+             * @since v14.5.0
+             */
+            listenerCount(type: string): number;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that sets the number
+             * of max event listeners as `n`.
+             * @since v14.5.0
+             */
+            setMaxListeners(n: number): void;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that returns the number
+             * of max event listeners.
+             * @since v14.5.0
+             */
+            getMaxListeners(): number;
+            /**
+             * Node.js-specific alias for `eventTarget.removeEventListener()`.
+             * @since v14.5.0
+             */
+            off(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+            /**
+             * Node.js-specific alias for `eventTarget.addEventListener()`.
+             * @since v14.5.0
+             */
+            on(type: string, listener: (arg: any) => void): this;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that adds a `once`
+             * listener for the given event `type`. This is equivalent to calling `on`
+             * with the `once` option set to `true`.
+             * @since v14.5.0
+             */
+            once(type: string, listener: (arg: any) => void): this;
+            /**
+             * Node.js-specific extension to the `EventTarget` class. If `type` is specified,
+             * removes all registered listeners for `type`, otherwise removes all registered
+             * listeners.
+             * @since v14.5.0
+             */
+            removeAllListeners(type?: string): this;
+            /**
+             * Node.js-specific extension to the `EventTarget` class that removes the
+             * `listener` for the given `type`. The only difference between `removeListener()`
+             * and `removeEventListener()` is that `removeListener()` will return a reference
+             * to the `EventTarget`.
+             * @since v14.5.0
+             */
+            removeListener(type: string, listener: (arg: any) => void, options?: EventListenerOptions): this;
+        }
     }
     global {
         namespace NodeJS {
-            interface EventEmitter {
-                [EventEmitter.captureRejectionSymbol]?(error: Error, event: string, ...args: any[]): void;
+            interface EventEmitter<T extends EventMap<T> = DefaultEventMap> {
+                [EventEmitter.captureRejectionSymbol]?<K>(error: Error, event: Key<K, T>, ...args: Args<K, T>): void;
                 /**
                  * Alias for `emitter.on(eventName, listener)`.
                  * @since v0.1.26
                  */
-                addListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                addListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
-                 * Adds the `listener` function to the end of the listeners array for the
-                 * event named `eventName`. No checks are made to see if the `listener` has
-                 * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
-                 * times.
+                 * Adds the `listener` function to the end of the listeners array for the event
+                 * named `eventName`. No checks are made to see if the `listener` has already
+                 * been added. Multiple calls passing the same combination of `eventName` and
+                 * `listener` will result in the `listener` being added, and called, multiple times.
                  *
                  * ```js
                  * server.on('connection', (stream) => {
@@ -522,7 +654,7 @@ declare module "events" {
                  *
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  *
-                 * By default, event listeners are invoked in the order they are added. The`emitter.prependListener()` method can be used as an alternative to add the
+                 * By default, event listeners are invoked in the order they are added. The `emitter.prependListener()` method can be used as an alternative to add the
                  * event listener to the beginning of the listeners array.
                  *
                  * ```js
@@ -539,9 +671,9 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                on(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                on<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
-                 * Adds a **one-time**`listener` function for the event named `eventName`. The
+                 * Adds a **one-time** `listener` function for the event named `eventName`. The
                  * next time `eventName` is triggered, this listener is removed and then invoked.
                  *
                  * ```js
@@ -552,7 +684,7 @@ declare module "events" {
                  *
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  *
-                 * By default, event listeners are invoked in the order they are added. The`emitter.prependOnceListener()` method can be used as an alternative to add the
+                 * By default, event listeners are invoked in the order they are added. The `emitter.prependOnceListener()` method can be used as an alternative to add the
                  * event listener to the beginning of the listeners array.
                  *
                  * ```js
@@ -569,9 +701,9 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                once(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                once<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
-                 * Removes the specified `listener` from the listener array for the event named`eventName`.
+                 * Removes the specified `listener` from the listener array for the event named `eventName`.
                  *
                  * ```js
                  * const callback = (stream) => {
@@ -588,7 +720,7 @@ declare module "events" {
                  * called multiple times to remove each instance.
                  *
                  * Once an event is emitted, all listeners attached to it at the
-                 * time of emitting are called in order. This implies that any`removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
+                 * time of emitting are called in order. This implies that any `removeListener()` or `removeAllListeners()` calls _after_ emitting and _before_ the last listener finishes execution
                  * will not remove them from`emit()` in progress. Subsequent events behave as expected.
                  *
                  * ```js
@@ -631,7 +763,7 @@ declare module "events" {
                  *
                  * When a single function has been added as a handler multiple times for a single
                  * event (as in the example below), `removeListener()` will remove the most
-                 * recently added instance. In the example the `once('ping')`listener is removed:
+                 * recently added instance. In the example the `once('ping')` listener is removed:
                  *
                  * ```js
                  * import { EventEmitter } from 'node:events';
@@ -652,12 +784,12 @@ declare module "events" {
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  * @since v0.1.26
                  */
-                removeListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                removeListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Alias for `emitter.removeListener()`.
                  * @since v10.0.0
                  */
-                off(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                off<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Removes all listeners, or those of the specified `eventName`.
                  *
@@ -668,12 +800,12 @@ declare module "events" {
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  * @since v0.1.26
                  */
-                removeAllListeners(event?: string | symbol): this;
+                removeAllListeners(eventName?: Key<unknown, T>): this;
                 /**
                  * By default `EventEmitter`s will print a warning if more than `10` listeners are
                  * added for a particular event. This is a useful default that helps finding
                  * memory leaks. The `emitter.setMaxListeners()` method allows the limit to be
-                 * modified for this specific `EventEmitter` instance. The value can be set to`Infinity` (or `0`) to indicate an unlimited number of listeners.
+                 * modified for this specific `EventEmitter` instance. The value can be set to `Infinity` (or `0`) to indicate an unlimited number of listeners.
                  *
                  * Returns a reference to the `EventEmitter`, so that calls can be chained.
                  * @since v0.3.5
@@ -681,7 +813,7 @@ declare module "events" {
                 setMaxListeners(n: number): this;
                 /**
                  * Returns the current max listener value for the `EventEmitter` which is either
-                 * set by `emitter.setMaxListeners(n)` or defaults to {@link defaultMaxListeners}.
+                 * set by `emitter.setMaxListeners(n)` or defaults to {@link EventEmitter.defaultMaxListeners}.
                  * @since v1.0.0
                  */
                 getMaxListeners(): number;
@@ -697,7 +829,7 @@ declare module "events" {
                  * ```
                  * @since v0.1.26
                  */
-                listeners(eventName: string | symbol): Function[];
+                listeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                 /**
                  * Returns a copy of the array of listeners for the event named `eventName`,
                  * including any wrappers (such as those created by `.once()`).
@@ -728,9 +860,9 @@ declare module "events" {
                  * ```
                  * @since v9.4.0
                  */
-                rawListeners(eventName: string | symbol): Function[];
+                rawListeners<K>(eventName: Key<K, T>): Array<Listener2<K, T>>;
                 /**
-                 * Synchronously calls each of the listeners registered for the event named`eventName`, in the order they were registered, passing the supplied arguments
+                 * Synchronously calls each of the listeners registered for the event named `eventName`, in the order they were registered, passing the supplied arguments
                  * to each.
                  *
                  * Returns `true` if the event had listeners, `false` otherwise.
@@ -769,7 +901,7 @@ declare module "events" {
                  * ```
                  * @since v0.1.26
                  */
-                emit(eventName: string | symbol, ...args: any[]): boolean;
+                emit<K>(eventName: Key<K, T>, ...args: Args<K, T>): boolean;
                 /**
                  * Returns the number of listeners listening for the event named `eventName`.
                  * If `listener` is provided, it will return how many times the listener is found
@@ -778,12 +910,12 @@ declare module "events" {
                  * @param eventName The name of the event being listened for
                  * @param listener The event handler function
                  */
-                listenerCount(eventName: string | symbol, listener?: Function): number;
+                listenerCount<K>(eventName: Key<K, T>, listener?: Listener2<K, T>): number;
                 /**
                  * Adds the `listener` function to the _beginning_ of the listeners array for the
                  * event named `eventName`. No checks are made to see if the `listener` has
-                 * already been added. Multiple calls passing the same combination of `eventName`and `listener` will result in the `listener` being added, and called, multiple
-                 * times.
+                 * already been added. Multiple calls passing the same combination of `eventName`
+                 * and `listener` will result in the `listener` being added, and called, multiple times.
                  *
                  * ```js
                  * server.prependListener('connection', (stream) => {
@@ -796,7 +928,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                prependListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                prependListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Adds a **one-time**`listener` function for the event named `eventName` to the _beginning_ of the listeners array. The next time `eventName` is triggered, this
                  * listener is removed, and then invoked.
@@ -812,7 +944,7 @@ declare module "events" {
                  * @param eventName The name of the event.
                  * @param listener The callback function
                  */
-                prependOnceListener(eventName: string | symbol, listener: (...args: any[]) => void): this;
+                prependOnceListener<K>(eventName: Key<K, T>, listener: Listener1<K, T>): this;
                 /**
                  * Returns an array listing the events for which the emitter has registered
                  * listeners. The values in the array are strings or `Symbol`s.
@@ -832,7 +964,7 @@ declare module "events" {
                  * ```
                  * @since v6.0.0
                  */
-                eventNames(): Array<string | symbol>;
+                eventNames(): Array<(string | symbol) & Key2<unknown, T>>;
             }
         }
     }