@signaldb/core 1.0.0 → 1.2.0

package/dist/index30.mjs

@@ -1,10 +1,30 @@
-function uniqueBy(arr, fn) {
-  const set = /* @__PURE__ */ new Set();
-  return arr.filter((el) => {
-    const value = typeof fn === "function" ? fn(el) : el[fn];
-    return !set.has(value) && set.add(value);
-  });
+function set(object, path, value, deleteIfUndefined = false) {
+  if (object == null)
+    return object;
+  const segments = path.split(/[.[\]]/g);
+  if (segments[0] === "")
+    segments.shift();
+  if (segments.at(-1) === "")
+    segments.pop();
+  const apply = (node) => {
+    if (segments.length > 1) {
+      const key = segments.shift();
+      const nextIsNumber = !Number.isNaN(Number.parseInt(segments[0], 10));
+      if (node[key] === void 0) {
+        node[key] = nextIsNumber ? [] : {};
+      }
+      apply(node[key]);
+    } else {
+      if (deleteIfUndefined && value === void 0) {
+        delete node[segments[0]];
+        return;
+      }
+      node[segments[0]] = value;
+    }
+  };
+  apply(object);
+  return object;
 }
 export {
-  uniqueBy as default
+  set as default
 };

package/dist/index31.mjs

@@ -0,0 +1,10 @@
+function uniqueBy(array, fn) {
+  const set = /* @__PURE__ */ new Set();
+  return array.filter((element) => {
+    const value = typeof fn === "function" ? fn(element) : element[fn];
+    return !set.has(value) && set.add(value);
+  });
+}
+export {
+  uniqueBy as default
+};

package/dist/index4.mjs

@@ -1,70 +1,174 @@
-import createPersistenceAdapter from "./index7.mjs";
-function createTemporaryFallbackExecutor(firstResolvingPromiseFn, secondResolvingPromiseFn, options) {
-  var _a;
-  const cacheTimeout = (_a = options === null || options === void 0 ? void 0 : options.cacheTimeout) !== null && _a !== void 0 ? _a : 0;
-  let isResolved = false;
-  let resolvedValue = null;
-  let timeout = null;
-  let secondaryPromise = null;
-  return (...args) => {
-    if (secondaryPromise == null) {
-      if (timeout) {
-        clearTimeout(timeout);
-        timeout = null;
+var __defProp = Object.defineProperty;
+var __defNormalProp = (obj, key, value) => key in obj ? __defProp(obj, key, { enumerable: true, configurable: true, writable: true, value }) : obj[key] = value;
+var __publicField = (obj, key, value) => __defNormalProp(obj, typeof key !== "symbol" ? key + "" : key, value);
+import ReplicatedCollection from "./index22.mjs";
+import createSignal from "./index19.mjs";
+class AutoFetchCollection extends ReplicatedCollection {
+  /**
+   * @param options {Object} - Options for the collection.
+   * @param options.fetchQueryItems {Function} - A function that fetches items from the server. It takes the selector as an argument and returns a promise that resolves to an object with an `items` property.
+   * @param options.purgeDelay {Number} - The delay in milliseconds before purging an item from the cache.
+   */
+  constructor(options) {
+    var _a;
+    let triggerRemoteChange;
+    super({
+      ...options,
+      pull: () => Promise.resolve({
+        items: [...this.itemsCache.values()].reduce((memo, items) => {
+          const newItems = [...memo];
+          items.forEach((item) => {
+            const index = newItems.findIndex((i) => i.id === item.id);
+            if (index === -1) {
+              newItems.push(item);
+              return;
+            }
+            newItems[index] = this.mergeItems(newItems[index], item);
+          });
+          return newItems;
+        }, [])
+      }),
+      registerRemoteChange: async (onChange) => {
+        triggerRemoteChange = onChange;
       }
-      secondaryPromise = secondResolvingPromiseFn(...args).then((result) => {
-        if (cacheTimeout > 0) {
-          timeout = setTimeout(() => {
-            isResolved = false;
-            resolvedValue = null;
-            secondaryPromise = null;
-          }, cacheTimeout);
-        }
-        isResolved = true;
-        resolvedValue = result;
-        if (options === null || options === void 0 ? void 0 : options.onResolve)
-          options.onResolve(resolvedValue);
-        return result;
-      });
-    } else if (isResolved) {
-      return secondaryPromise;
+    });
+    __publicField(this, "activeObservers", /* @__PURE__ */ new Map());
+    __publicField(this, "observerTimeouts", /* @__PURE__ */ new Map());
+    __publicField(this, "purgeDelay");
+    __publicField(this, "idQueryCache", /* @__PURE__ */ new Map());
+    __publicField(this, "itemsCache", /* @__PURE__ */ new Map());
+    __publicField(this, "fetchQueryItems");
+    __publicField(this, "triggerReload", null);
+    __publicField(this, "reactivityAdapter", null);
+    __publicField(this, "loadingSignals", /* @__PURE__ */ new Map());
+    __publicField(this, "isFetchingSignal");
+    __publicField(this, "mergeItems");
+    this.mergeItems = options.mergeItems ?? ((itemA, itemB) => ({ ...itemA, ...itemB }));
+    this.purgeDelay = options.purgeDelay ?? 1e4;
+    this.isFetchingSignal = createSignal((_a = options.reactivity) == null ? void 0 : _a.create(), false);
+    if (!triggerRemoteChange)
+      throw new Error("No triggerRemoteChange method found. Looks like your persistence adapter was not registered");
+    this.triggerReload = triggerRemoteChange;
+    this.reactivityAdapter = options.reactivity ?? null;
+    this.fetchQueryItems = options.fetchQueryItems;
+    this.on("observer.created", (selector) => this.handleObserverCreation(selector ?? {}));
+    this.on("observer.disposed", (selector) => setTimeout(() => this.handleObserverDisposal(selector ?? {}), 100));
+    if (options.registerRemoteChange) {
+      void options.registerRemoteChange(() => this.forceRefetch());
     }
-    return firstResolvingPromiseFn(...args);
-  };
-}
-function combinePersistenceAdapters(slowAdapter, fastAdapter) {
-  let handleChange = null;
-  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
-    cacheTimeout: 100,
-    onResolve: (result) => {
-      var _a, _b, _c;
-      if (handleChange)
-        void handleChange();
-      void fastAdapter.save(result.items || [], {
-        added: ((_a = result.changes) === null || _a === void 0 ? void 0 : _a.added) || [],
-        modified: ((_b = result.changes) === null || _b === void 0 ? void 0 : _b.modified) || [],
-        removed: ((_c = result.changes) === null || _c === void 0 ? void 0 : _c.removed) || []
+  }
+  /**
+   * Registers a query manually that items should be fetched for it
+   * @param selector {Object} Selector of the query
+   */
+  registerQuery(selector) {
+    this.handleObserverCreation(selector);
+  }
+  /**
+   * Unregisters a query manually that items are not fetched anymore for it
+   * @param selector {Object} Selector of the query
+   */
+  unregisterQuery(selector) {
+    this.handleObserverDisposal(selector);
+  }
+  getKeyForSelector(selector) {
+    return JSON.stringify(selector);
+  }
+  async forceRefetch() {
+    return Promise.all([...this.activeObservers.values()].map(({ selector }) => this.fetchSelector(selector))).then(() => {
+    });
+  }
+  fetchSelector(selector) {
+    this.isFetchingSignal.set(true);
+    return this.fetchQueryItems(selector).then((response) => {
+      if (!response.items)
+        throw new Error("AutoFetchCollection currently only works with a full item response");
+      this.itemsCache.set(this.getKeyForSelector(selector), response.items);
+      response.items.forEach((item) => {
+        const queries = this.idQueryCache.get(item.id) ?? [];
+        queries.push(selector);
+        this.idQueryCache.set(item.id, queries);
+      });
+      this.setLoading(selector, true);
+      this.once("persistence.received", () => {
+        this.setLoading(selector, false);
       });
+      if (!this.triggerReload)
+        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
+      void this.triggerReload();
+    }).catch((error) => {
+      this.emit("persistence.error", error);
+    }).finally(() => {
+      this.isFetchingSignal.set(false);
+    });
+  }
+  handleObserverCreation(selector) {
+    var _a;
+    const activeObservers = ((_a = this.activeObservers.get(this.getKeyForSelector(selector))) == null ? void 0 : _a.count) ?? 0;
+    this.activeObservers.set(this.getKeyForSelector(selector), {
+      selector,
+      count: activeObservers + 1
+    });
+    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
+    if (timeout)
+      clearTimeout(timeout);
+    if (activeObservers === 0)
+      void this.fetchSelector(selector);
+  }
+  handleObserverDisposal(selector) {
+    var _a;
+    const currentObservers = ((_a = this.activeObservers.get(this.getKeyForSelector(selector))) == null ? void 0 : _a.count) ?? 0;
+    const activeObservers = currentObservers - 1;
+    if (activeObservers > 0) {
+      this.activeObservers.set(this.getKeyForSelector(selector), {
+        selector,
+        count: activeObservers
+      });
+      return;
+    }
+    const timeout = this.observerTimeouts.get(this.getKeyForSelector(selector));
+    if (timeout)
+      clearTimeout(timeout);
+    const removeObserver = () => {
+      this.activeObservers.delete(this.getKeyForSelector(selector));
+      this.itemsCache.delete(this.getKeyForSelector(selector));
+      if (!this.triggerReload)
+        throw new Error("No triggerReload method found. Looks like your persistence adapter was not registered");
+      void this.triggerReload();
+    };
+    if (this.purgeDelay === 0) {
+      removeObserver();
+      return;
+    }
+    this.observerTimeouts.set(this.getKeyForSelector(selector), setTimeout(removeObserver, this.purgeDelay));
+  }
+  ensureSignal(selector) {
+    if (!this.reactivityAdapter)
+      throw new Error("No reactivity adapter found");
+    if (!this.loadingSignals.has(this.getKeyForSelector(selector))) {
+      this.loadingSignals.set(this.getKeyForSelector(selector), createSignal(this.reactivityAdapter.create(), false));
     }
-  });
-  return createPersistenceAdapter({
-    async register(onChange) {
-      handleChange = onChange;
-      await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
-    },
-    async load() {
-      const promise = readExecutor();
-      return promise;
-    },
-    async save(items, changes) {
-      await Promise.all([
-        fastAdapter.save(items, changes),
-        slowAdapter.save(items, changes)
-      ]);
+    return this.loadingSignals.get(this.getKeyForSelector(selector));
+  }
+  setLoading(selector, value) {
+    const signal = this.ensureSignal(selector);
+    signal.set(value);
+  }
+  /**
+   * Indicates wether a query is currently been loaded
+   * ⚡️ this function is reactive!
+   * @param selector {Object} Selector of the query
+   * @returns The loading state
+   */
+  isLoading(selector) {
+    const isPushing = this.isPushing();
+    if (!selector) {
+      return this.isFetchingSignal.get() || isPushing;
     }
-  });
+    const signal = this.ensureSignal(selector);
+    return signal.get() || isPushing;
+  }
 }
 export {
-  createTemporaryFallbackExecutor,
-  combinePersistenceAdapters as default
+  AutoFetchCollection as default
 };

package/dist/index5.mjs

@@ -1,6 +1,68 @@
-function createIndexProvider(definition) {
-  return definition;
+import createPersistenceAdapter from "./index8.mjs";
+function createTemporaryFallbackExecutor(firstResolvingPromiseFunction, secondResolvingPromiseFunction, options) {
+  const cacheTimeout = options == null ? void 0 : options.cacheTimeout;
+  let isResolved = false;
+  let resolvedValue = null;
+  let timeout = null;
+  let secondaryPromise = null;
+  return (...args) => {
+    if (secondaryPromise == null) {
+      if (timeout) {
+        clearTimeout(timeout);
+        timeout = null;
+      }
+      secondaryPromise = secondResolvingPromiseFunction(...args).then((result) => {
+        {
+          timeout = setTimeout(() => {
+            isResolved = false;
+            resolvedValue = null;
+            secondaryPromise = null;
+          }, cacheTimeout);
+        }
+        isResolved = true;
+        resolvedValue = result;
+        options.onResolve(resolvedValue);
+        return result;
+      });
+    } else if (isResolved) {
+      return secondaryPromise;
+    }
+    return firstResolvingPromiseFunction(...args);
+  };
+}
+function combinePersistenceAdapters(slowAdapter, fastAdapter) {
+  let handleChange = null;
+  const readExecutor = createTemporaryFallbackExecutor(() => fastAdapter.load(), () => slowAdapter.load(), {
+    cacheTimeout: 100,
+    onResolve: (result) => {
+      var _a, _b, _c;
+      if (handleChange)
+        void handleChange();
+      void fastAdapter.save(result.items || [], {
+        added: ((_a = result.changes) == null ? void 0 : _a.added) || [],
+        modified: ((_b = result.changes) == null ? void 0 : _b.modified) || [],
+        removed: ((_c = result.changes) == null ? void 0 : _c.removed) || []
+      });
+    }
+  });
+  return createPersistenceAdapter({
+    async register(onChange) {
+      handleChange = onChange;
+      await Promise.all([slowAdapter.register(onChange), fastAdapter.register(onChange)]);
+    },
+    async load() {
+      const promise = readExecutor();
+      return promise;
+    },
+    async save(items, changes) {
+      await Promise.all([
+        fastAdapter.save(items, changes),
+        slowAdapter.save(items, changes)
+      ]);
+    }
+  });
 }
 export {
-  createIndexProvider as default
+  createTemporaryFallbackExecutor,
+  combinePersistenceAdapters as default
 };

package/dist/index6.mjs

@@ -1,6 +1,6 @@
-function createMemoryAdapter(definition) {
+function createIndexProvider(definition) {
   return definition;
 }
 export {
-  createMemoryAdapter as default
+  createIndexProvider as default
 };

package/dist/index7.mjs

@@ -1,6 +1,6 @@
-function createPersistenceAdapter(definition) {
+function createMemoryAdapter(definition) {
   return definition;
 }
 export {
-  createPersistenceAdapter as default
+  createMemoryAdapter as default
 };

package/dist/index8.mjs

@@ -1,6 +1,6 @@
-function createReactivityAdapter(definition) {
+function createPersistenceAdapter(definition) {
   return definition;
 }
 export {
-  createReactivityAdapter as default
+  createPersistenceAdapter as default
 };

package/dist/index9.mjs

@@ -1,31 +1,6 @@
-function isEqual(a, b) {
-  if (Object.is(a, b))
-    return true;
-  if (a instanceof RegExp && b instanceof RegExp)
-    return a.toString() === b.toString();
-  if (a instanceof Date && b instanceof Date)
-    return a.getTime() === b.getTime();
-  if (typeof a !== "object")
-    return false;
-  if (typeof b !== "object")
-    return false;
-  if (a === null)
-    return false;
-  if (b === null)
-    return false;
-  const aKeys = Object.keys(a);
-  const bKeys = Object.keys(b);
-  if (aKeys.length !== bKeys.length)
-    return false;
-  for (let i = 0; i < aKeys.length; i += 1) {
-    const key = aKeys[i];
-    if (!bKeys.includes(key))
-      return false;
-    if (!isEqual(a[key], b[key]))
-      return false;
-  }
-  return true;
+function createReactivityAdapter(definition) {
+  return definition;
 }
 export {
-  isEqual as default
+  createReactivityAdapter as default
 };

package/dist/persistence/combinePersistenceAdapters.d.ts

@@ -4,19 +4,19 @@ import type PersistenceAdapter from '../types/PersistenceAdapter';
  * The first function is tried first, and if it resolves, its value is used.
  * If the first function fails or a fallback is required, the second function is executed.
  * An optional cache mechanism can store the result temporarily to improve performance.
- * @template Args - The argument types for the promise functions.
- * @template ReturnVal - The return value type of the promise functions.
- * @param firstResolvingPromiseFn - The primary promise-based function to execute.
- * @param secondResolvingPromiseFn - The secondary fallback promise-based function to execute.
+ * @template Arguments - The argument types for the promise functions.
+ * @template ReturnValue - The return value type of the promise functions.
+ * @param firstResolvingPromiseFunction - The primary promise-based function to execute.
+ * @param secondResolvingPromiseFunction - The secondary fallback promise-based function to execute.
  * @param [options] - Optional configuration.
  * @param [options.onResolve] - Callback executed when a promise resolves.
  * @param [options.cacheTimeout] - Time (in ms) to cache the resolved result.
  * @returns A function that executes the two promises as described.
  */
-export declare function createTemporaryFallbackExecutor<Args extends Array<any>, ReturnVal>(firstResolvingPromiseFn: (...args: Args) => Promise<ReturnVal>, secondResolvingPromiseFn: (...args: Args) => Promise<ReturnVal>, options?: {
-    onResolve?: (returnValue: ReturnVal) => void;
+export declare function createTemporaryFallbackExecutor<Arguments extends Array<any>, ReturnValue>(firstResolvingPromiseFunction: (...args: Arguments) => Promise<ReturnValue>, secondResolvingPromiseFunction: (...args: Arguments) => Promise<ReturnValue>, options?: {
+    onResolve?: (returnValue: ReturnValue) => void;
     cacheTimeout?: number;
-}): (...args: Args) => Promise<ReturnVal>;
+}): (...args: Arguments) => Promise<ReturnValue>;
 /**
  * Combines two persistence adapters (fast and slow) into a single interface.
  * The fast adapter is used for quick read and write operations, while the slow adapter

package/dist/types/MemoryAdapter.d.ts

@@ -9,7 +9,7 @@ export default abstract class MemoryAdapter<T = Record<string, any>> {
     abstract pop(): T | undefined;
     abstract splice(start: number, deleteCount?: number, ...items: T[]): T[];
     abstract map<U>(callbackfn: (value: T, index: number, array: T[]) => U): U[];
-    abstract find(predicate: (value: T, index: number, obj: T[]) => boolean): T | undefined;
+    abstract find(predicate: (value: T, index: number, object: T[]) => boolean): T | undefined;
     abstract filter(predicate: (value: T, index: number, array: T[]) => unknown): T[];
-    abstract findIndex(predicate: (value: T, index: number, obj: T[]) => boolean): number;
+    abstract findIndex(predicate: (value: T, index: number, object: T[]) => boolean): number;
 }

package/dist/utils/EventEmitter.d.ts

@@ -0,0 +1,75 @@
+/**
+ * A strongly‑typed EventEmitter using the native EventTarget under the hood.
+ */
+export default class EventEmitter<Events extends Record<string | symbol, any>> extends EventTarget {
+    private _maxListeners;
+    /**
+     * We store a map of:
+     *   eventName => (originalListener => wrappedListener)
+     *
+     * The "wrappedListener" is the actual function passed to `addEventListener()`.
+     */
+    private _listenerStore;
+    setMaxListeners(max: number): this;
+    /**
+     * Subscribe to an event with a listener function.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    on<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * Subscribe to an event with a listener function.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    addListener<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * Subscribe to an event, handling it only once. Automatically removes
+     * the listener after it fires the first time.
+     * @param eventName The event name (key of E).
+     * @param listener  A function that receives the emitted arguments.
+     * @returns         The emitter instance (for chaining).
+     */
+    once<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * Unsubscribe a previously subscribed listener.
+     * @param eventName The event name (key of E).
+     * @param listener  The original function passed to `on` or `once`.
+     * @returns         The emitter instance (for chaining).
+     */
+    off<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * Unsubscribe a previously subscribed listener.
+     * @param eventName The event name (key of E).
+     * @param listener  The original function passed to `on` or `once`.
+     * @returns         The emitter instance (for chaining).
+     */
+    removeListener<K extends keyof Events>(eventName: K, listener: Events[K]): this;
+    /**
+     * Emit (dispatch) an event with a variable number of arguments.
+     * @param eventName The event name (key of E).
+     * @param args      The arguments to pass to subscribed listeners.
+     * @returns         A boolean indicating if the event was not cancelled.
+     */
+    emit<K extends keyof Events>(eventName: K, ...args: Parameters<Events[K]>): boolean;
+    /**
+     * Returns the array of listener functions currently registered for a given event.
+     * @param eventName The event name (key of E).
+     * @returns         An array of listener functions.
+     */
+    listeners<K extends keyof Events>(eventName: K): Array<(...args: Parameters<Events[K]>) => void>;
+    /**
+     * Returns the number of listeners for a given event.
+     * @param eventName The event name (key of E).
+     * @returns         The number of listeners.
+     */
+    listenerCount<K extends keyof Events>(eventName: K): number;
+    /**
+     * Removes all listeners for a given event, or all events if none is specified.
+     * @param eventName Optional. If omitted, clears all events’ listeners.
+     * @returns         The emitter instance (for chaining).
+     */
+    removeAllListeners<K extends keyof Events>(eventName?: K): this;
+}

package/dist/utils/deepClone.d.ts

@@ -11,7 +11,7 @@ export declare function clone<T>(value: T): T;
  * Creates a deep clone of an object. Uses the `structuredClone` function if available,
  * otherwise falls back to a manual deep clone implementation.
  * @template T - The type of the object to clone.
- * @param obj - The object to deep clone.
+ * @param object - The object to deep clone.
  * @returns A deep copy of the provided object.
  */
-export default function deepClone<T>(obj: T): T;
+export default function deepClone<T>(object: T): T;

package/dist/utils/set.d.ts

@@ -4,10 +4,10 @@
  * deleting the key if the value is `undefined` and the `deleteIfUndefined` flag is set to `true`.
  * @template T - The type of the object to modify.
  * @template K - The type of the value to set.
- * @param obj - The object to modify. The object is mutated directly.
+ * @param object - The object to modify. The object is mutated directly.
  * @param path - The path (dot or bracket notation) where the value should be set.
  * @param value - The value to set at the specified path.
  * @param deleteIfUndefined - A boolean indicating whether to delete the key if the value is `undefined` (default: `false`).
  * @returns The modified object.
  */
-export default function set<T extends object, K>(obj: T, path: string, value: K, deleteIfUndefined?: boolean): T;
+export default function set<T extends object, K>(object: T, path: string, value: K, deleteIfUndefined?: boolean): T;

package/dist/utils/uniqueBy.d.ts

@@ -1,10 +1,10 @@
 /**
  * Filters an array to ensure unique values based on a specified key or transformation function.
  * @template T - The type of the elements in the array.
- * @param arr - The array to filter for unique values.
+ * @param array - The array to filter for unique values.
  * @param fn - A key or transformation function to determine uniqueness.
  *   - If a key is provided, it will use the corresponding property of each element for uniqueness.
  *   - If a function is provided, it will use the return value of the function applied to each element for uniqueness.
  * @returns A new array containing only unique elements based on the specified key or transformation.
  */
-export default function uniqueBy<T>(arr: T[], fn: keyof T | ((item: T) => any)): T[];
+export default function uniqueBy<T>(array: T[], fn: keyof T | ((item: T) => any)): T[];

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@signaldb/core",
-  "version": "1.0.0",
+  "version": "1.2.0",
   "description": "SignalDB is a client-side database that provides a simple MongoDB-like interface to the data with first-class typescript support to achieve an optimistic UI. Data persistence can be achieved by using storage providers that store the data through a JSON interface to places such as localStorage.",
   "scripts": {
     "build": "rimraf dist && vite build"

package/dist/types/EventEmitter.d.ts

@@ -1,25 +0,0 @@
-import { EventEmitter as BaseEventEmitter } from 'events';
-/**
- * Extends the `EventEmitter` class from Node.js to provide a strongly-typed
- * event emitter that enforces type safety for events and their corresponding listeners.
- * @template Events - A record where keys represent event names (string or symbol),
- *   and values represent the listener function types for those events.
- */
-export default class EventEmitter<Events extends Record<string | symbol, any>> extends BaseEventEmitter {
-    /**
-     * Registers a listener for the specified event.
-     * @template K - The key of the event in the `Events` record.
-     * @param event - The name of the event to listen for.
-     * @param listener - The listener function to execute when the event is emitted.
-     * @returns The `EventEmitter` instance, allowing for method chaining.
-     */
-    on<K extends keyof Events>(event: K, listener: Events[K]): this;
-    /**
-     * Emits the specified event, triggering all registered listeners for that event.
-     * @template K - The key of the event in the `Events` record.
-     * @param event - The name of the event to emit.
-     * @param args - The arguments to pass to the event listeners.
-     * @returns A boolean indicating whether any listeners were triggered.
-     */
-    emit<K extends keyof Events>(event: K, ...args: Parameters<Events[K]>): boolean;
-}