@lakutata/core 1.0.59 → 3.0.0-beta.0

package/dist/types/lib/base/internal/MethodAssistantFunction.d.ts

@@ -0,0 +1,20 @@
+export type BeforeFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown> = (this: ClassPrototype, ...args: Parameters<Method>) => Promise<Parameters<Method> | void> | Parameters<Method> | void;
+export type AfterFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown> = (this: ClassPrototype, result: Awaited<ReturnType<Method>>) => Promise<ReturnType<Method> | void> | ReturnType<Method> | void;
+/**
+ * Register a function which will run before target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param beforeFunction
+ * @constructor
+ */
+export declare function registerBeforeFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Method>, beforeFunction: BeforeFunction<ClassPrototype, Method>): TypedPropertyDescriptor<Method>;
+/**
+ * Register a function which will run after target method
+ * @param target
+ * @param propertyKey
+ * @param descriptor
+ * @param afterFunction
+ * @constructor
+ */
+export declare function registerAfterFunction<ClassPrototype extends Object, Method extends (...args: any[]) => unknown>(target: ClassPrototype, propertyKey: string | symbol, descriptor: TypedPropertyDescriptor<Method>, afterFunction: AfterFunction<ClassPrototype, Method>): TypedPropertyDescriptor<Method>;

package/dist/types/lib/base/internal/ModuleConfigLoader.d.ts

@@ -0,0 +1,46 @@
+import { BootstrapOption, type ModuleOptions } from '../../../options/ModuleOptions.js';
+import { LoadObjectOptions } from '../../../options/LoadObjectOptions.js';
+import { Module } from '../../core/Module.js';
+import { BaseObject } from '../BaseObject.js';
+import { OverridableNamedObjectOptions } from '../../../options/OverridableNamedObjectOptions.js';
+import { ObjectType } from './ObjectType.js';
+import { IBaseObjectConstructor } from '../../../interfaces/IBaseObjectConstructor.js';
+/**
+ * Module configurations loader
+ */
+export declare class ModuleConfigLoader {
+    protected readonly $module: Module;
+    protected readonly $presetLoadOptionsSet: Set<LoadObjectOptions | typeof BaseObject | string>;
+    protected readonly $loadOptions: (LoadObjectOptions | typeof BaseObject | string)[];
+    protected readonly $bootstrap: BootstrapOption[];
+    /**
+     * Constructor
+     * @param module
+     * @param moduleOptions
+     * @param presetLoadOptions
+     */
+    constructor(module: Module, moduleOptions: ModuleOptions, presetLoadOptions?: (LoadObjectOptions | typeof BaseObject | string)[]);
+    /**
+     * Validate constructor's object type
+     * @param expectObjectType
+     * @param target
+     * @param id
+     * @protected
+     */
+    protected validateObjectType<ClassConstructor extends IBaseObjectConstructor>(expectObjectType: ObjectType, target: ClassConstructor, id?: string): ClassConstructor;
+    /**
+     * Process overridable named object options
+     * @param objectType
+     * @param options
+     * @protected
+     */
+    protected processOverridableNamedObjectOptions(objectType: ObjectType, options?: OverridableNamedObjectOptions): void;
+    /**
+     * Load options for container.load()
+     */
+    get loadOptions(): (LoadObjectOptions | typeof BaseObject | string)[];
+    /**
+     * Load bootstrap for module
+     */
+    get bootstrap(): BootstrapOption[];
+}

package/dist/types/lib/base/internal/ModuleInitialization.d.ts

@@ -0,0 +1,5 @@
+/**
+ * The method of a module giving its initialization (its objects loaded, its bootstrap run): the container resolving the
+ * module for an object outside it waits for it
+ */
+export declare const MODULE_INITIALIZATION: symbol;

package/dist/types/lib/base/internal/ObjectConfiguration.d.ts

@@ -0,0 +1,29 @@
+import { BaseObject } from '../BaseObject.js';
+import { Schema } from '../../validation/types/Schema.js';
+export type ObjectConfigurablePropertyMap<DataType = any> = Map<string | symbol, {
+    schema: Schema<DataType>;
+    fn: (value: DataType) => DataType | Promise<DataType>;
+}>;
+/**
+ * Add object configurable property to Set
+ * @param target
+ * @param propertyKey
+ * @param schema
+ * @param fn
+ * @constructor
+ */
+export declare function setObjectConfigurableProperty<ClassPrototype extends BaseObject, DataType>(target: ClassPrototype, propertyKey: string | symbol, schema?: Schema<DataType>, fn?: (value: DataType) => DataType | Promise<DataType>): void;
+/**
+ * Remove the configurable property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export declare function removeObjectConfigurableProperty<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol): void;
+/**
+ * Get object configurable properties by its prototype: the ones of the class and of its parents, the closest
+ * declaration of a property winning
+ * @param target
+ * @constructor
+ */
+export declare function getObjectConfigurableProperties<ClassPrototype extends BaseObject>(target: ClassPrototype): ObjectConfigurablePropertyMap;

package/dist/types/lib/base/internal/ObjectContainer.d.ts

@@ -0,0 +1,15 @@
+import { Container } from '../../core/Container.js';
+import { BaseObject } from '../BaseObject.js';
+/**
+ * Set container getter
+ * @param target
+ * @param container
+ * @constructor
+ */
+export declare function setObjectContainerGetter<ClassPrototype extends BaseObject>(target: ClassPrototype, container: Container): void;
+/**
+ * Get container via class prototype
+ * @param target
+ * @constructor
+ */
+export declare function getObjectContainer<ClassPrototype extends BaseObject>(target: ClassPrototype): Container;

package/dist/types/lib/base/internal/ObjectInjection.d.ts

@@ -0,0 +1,43 @@
+import { BaseObject } from '../BaseObject.js';
+import { IBaseObjectConstructor } from '../../../interfaces/IBaseObjectConstructor.js';
+export type InjectionName = string | symbol | IBaseObjectConstructor<BaseObject>;
+export type InjectionTransformFunction = (injection: any) => any | Promise<any>;
+export type ObjectInjectionMap = Map<string | symbol, {
+    name: string | symbol | Function;
+    transform: InjectionTransformFunction;
+}>;
+/**
+ * Set object inject item
+ * @param target
+ * @param propertyKey
+ * @param name
+ * @param transform
+ * @constructor
+ */
+export declare function setObjectInjectItem<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol, name: string | symbol | Function, transform: InjectionTransformFunction): void;
+/**
+ * Remove the injection of a property of the parents of a class: the class declares the property otherwise
+ * @param target
+ * @param propertyKey
+ * @constructor
+ */
+export declare function removeObjectInjectItem<ClassPrototype extends BaseObject>(target: ClassPrototype, propertyKey: string | symbol): void;
+/**
+ * Get object inject items by its prototype: the ones of the class and of its parents, the closest declaration of a
+ * property winning
+ * @param target
+ * @constructor
+ */
+export declare function getObjectInjectItemsByPrototype<ClassPrototype extends BaseObject>(target: ClassPrototype): ObjectInjectionMap;
+/**
+ * Mark object as autoload
+ * @param target
+ * @constructor
+ */
+export declare function markObjectAsAutoload<ClassConstructor extends typeof BaseObject>(target: ClassConstructor): ClassConstructor;
+/**
+ * Whether an object is autoload object or not
+ * @param target
+ * @constructor
+ */
+export declare function getObjectIsAutoload<ClassConstructor extends typeof BaseObject>(target: ClassConstructor): boolean;

package/dist/types/lib/base/internal/ObjectOptionsCheck.d.ts

@@ -0,0 +1,12 @@
+import { BaseObject } from '../BaseObject.js';
+import { LoadObjectOptions } from '../../../options/LoadObjectOptions.js';
+/**
+ * Check the options of the objects declared in a module, before any of them is created (an object never created is
+ * checked too): an invalid value of a configurable property is an error, an option which is not a configurable property
+ * and which the class does not accept (see BaseObject.acceptsOption()) is a warning. The values are validated as the
+ * objects validate them, without their transforms. The options not given are not checked (they may be given when the
+ * object is got), nor the properties validated asynchronously (by external rules), which the object validates
+ * @param loadOptions
+ * @constructor
+ */
+export declare function checkObjectOptions(loadOptions: (LoadObjectOptions | typeof BaseObject | string)[]): void;

package/dist/types/lib/base/internal/ObjectStartup.d.ts

@@ -0,0 +1,31 @@
+/**
+ * Run the startup of an object, after its initialization: the objects getting it wait for its startup, except the
+ * call chain of its startup itself, which gets it at once (initialized, not started yet)
+ * @param object The object.
+ * @param startup Its startup.
+ * @returns The startup, its failure handled (it is delivered to the objects getting the object).
+ * @internal
+ */
+export declare function runObjectStartup(object: object, startup: () => Promise<void>): Promise<void>;
+/**
+ * Tell whether the current call chain belongs to the startup of an object
+ * @param object The object.
+ * @returns true within its startup.
+ * @internal
+ */
+export declare function isInObjectStartup(object: object): boolean;
+/**
+ * Wait for the startup of an object given to a requester (at once without startup, or within its startup)
+ * @param object The object.
+ * @returns Resolves once it started, rejects with the error of its startup.
+ * @internal
+ */
+export declare function waitForObjectStartup(object: object): Promise<void>;
+/**
+ * The end of the startup of an object, its failure ignored (its teardown waits for it): none when it has no startup
+ * running, or within its startup, so that its teardown goes on in the same turn
+ * @param object The object.
+ * @returns Resolves once its startup ended; undefined when there is nothing to wait for.
+ * @internal
+ */
+export declare function waitForObjectStartupEnd(object: object): Promise<void> | undefined;

package/dist/types/lib/base/internal/ObjectType.d.ts

@@ -0,0 +1,37 @@
+import { IBaseObjectConstructor } from '../../../interfaces/IBaseObjectConstructor.js';
+import { ClassDecorator } from '../../../types/ClassDecorator.js';
+/**
+ * Object Type
+ */
+export declare enum ObjectType {
+    Unknown = "Unknown",
+    Object = "Object",
+    Provider = "Provider",
+    Component = "Component",
+    Module = "Module"
+}
+/**
+ * Register BaseObject
+ * @param constructor
+ * @constructor
+ */
+export declare function registerBaseObject(constructor: Function): void;
+/**
+ * Class Decorator
+ * @param type
+ * @constructor
+ */
+export declare function DefineObjectType<ClassConstructor extends IBaseObjectConstructor>(type: ObjectType): ClassDecorator<ClassConstructor>;
+/**
+ * Set object type
+ * @param target
+ * @param type
+ * @constructor
+ */
+export declare function setObjectType<ClassConstructor extends IBaseObjectConstructor>(target: ClassConstructor, type: ObjectType): ClassConstructor;
+/**
+ * Get object type
+ * @param target
+ * @constructor
+ */
+export declare function getObjectType<ClassConstructor extends IBaseObjectConstructor>(target: ClassConstructor): ObjectType;

package/dist/types/lib/core/Alias.d.ts

@@ -0,0 +1,48 @@
+export declare class Alias {
+    protected aliasNameRegExp: RegExp;
+    protected readonly aliasMap: Map<string, string>;
+    /**
+     * Constructor
+     */
+    constructor();
+    /**
+     * Init alias manager, must init it before application instance init
+     */
+    static init(): void;
+    /**
+     * Get alias manager instance
+     */
+    static getAliasInstance(): Alias;
+    /**
+     * Register alias
+     * @param aliasName
+     * @param aliasPath
+     */
+    set(aliasName: string, aliasPath: string): void;
+    /**
+     * Register alias
+     * @param aliasName
+     * @param aliasPath
+     * @param override
+     */
+    set(aliasName: string, aliasPath: string, override: boolean): void;
+    /**
+     * Resolve alias
+     * @param aliasName
+     */
+    get(aliasName: string): string;
+    /**
+     * Whether an alias exists
+     * @param aliasName
+     */
+    has(aliasName: string): boolean;
+    /**
+     * Resolve string and replace alias name to alias value inside the string
+     * @param containAliasPath
+     */
+    resolve(containAliasPath: string): string;
+    /**
+     * List aliases
+     */
+    list(): Record<string, string>;
+}

package/dist/types/lib/core/Component.d.ts

@@ -0,0 +1,267 @@
+import { __destroy, __init } from '../base/BaseObject.js';
+import { type event, type ListenerFn, type EventAndListener } from '../base/EventEmitter.js';
+import { Provider } from './Provider.js';
+import { Container } from './Container.js';
+/**
+ * The base class of the components: the long-lived objects shared by the whole application (a logger, a database
+ * connection, a cache, an entrypoint). Its lifetime is `@Singleton`, locked: one instance per container registering
+ * it, and a subclass declaring another lifetime throws a {@link LifetimeLockedException}.
+ *
+ * Declare it in the `components` of the application or module options, under a name, with its options; it is created
+ * on first request (`@Inject`, `getObject()`), or at launch when its name is listed in `bootstrap`. A component is an
+ * event emitter: its events support namespaces (`'order.paid'`) and wildcards (`'order.*'`), and its listeners added
+ * by `on()`, `once()`, `many()` and their prepended forms run asynchronously after the emitting. Its listeners are
+ * removed at its teardown.
+ * @example
+ * ```typescript
+ * import {Application, Component, Module} from 'lakutata'
+ *
+ * export class Orders extends Component {
+ *     public async pay(id: number): Promise<void> {
+ *         //...
+ *         this.emit('order.paid', id)
+ *     }
+ * }
+ *
+ * Application.run({
+ *     id: 'shop.app',
+ *     name: 'Shop',
+ *     components: {
+ *         orders: {class: Orders}
+ *     },
+ *     bootstrap: [
+ *         async (app: Module): Promise<void> => {
+ *             const orders: Orders = await app.getObject<Orders>('orders')
+ *             orders.on('order.*', (id: number): void => console.log(`Order ${id} changed`))
+ *         }
+ *     ]
+ * })
+ * ```
+ */
+export declare class Component extends Provider {
+    #private;
+    /**
+     * The number of listeners of one event above which a possible memory leak is warned of (0: no warning); the
+     * listeners are never limited. A subclass gives its own default by an initializer
+     * (`protected readonly maxListeners: number = 0`).
+     * @default 11
+     * @protected
+     */
+    protected readonly maxListeners: number;
+    /**
+     * The framework's initializer, see {@link BaseObject}; override `init()` instead.
+     * @param hooks The steps the framework's subclasses run before `init()`.
+     * @returns Resolves once the component is ready.
+     * @protected
+     */
+    protected [__init](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * The framework's destroyer, see {@link BaseObject}: it also removes all the listeners; override `beforeDestroy()`
+     * and `destroy()` instead.
+     * @param hooks The steps the framework's subclasses run before `destroy()`.
+     * @returns Resolves once the component is destroyed.
+     * @protected
+     */
+    protected [__destroy](...hooks: (() => Promise<void>)[]): Promise<void>;
+    /**
+     * The component's own container: the objects it registers or creates there are destroyed with it.
+     * @protected
+     */
+    protected get container(): Container;
+    /**
+     * Create a scope from the component's container (see {@link Container.createScope}), such as one per request:
+     * the scoped objects got from it are its own instances. Destroy it once done; it is destroyed with the component
+     * otherwise.
+     * @returns The new scope.
+     * @throws {ObjectDestroyedException} When the component's container has been destroyed.
+     * @protected
+     */
+    protected createScope(): Container;
+    /**
+     * Emit an event: the listeners added by `addListener()` and `onAny()` are called now, in order; the ones added by
+     * `on()`, `once()`, `many()` and their prepended forms are scheduled (an error they throw is an unhandled
+     * rejection). Use `emitRequest()` to wait for the listeners and their results.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param values The values passed to the listeners.
+     * @returns true when the event has listeners.
+     * @throws {Error} The error emitted as an `'error'` event which has no listener.
+     */
+    emit(event: string | symbol | event[], ...values: any[]): boolean;
+    /**
+     * Emit an event and wait for its listeners (the asynchronous ones included).
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param values The values passed to the listeners.
+     * @returns The results of the listeners, in their order (an empty array without listener).
+     * @throws {Error} The first error thrown by a listener, or the error emitted as an `'error'` event which has no
+     * listener.
+     */
+    emitRequest(event: string | symbol | event[], ...values: any[]): Promise<any[]>;
+    /**
+     * Add a listener called synchronously, at the emitting, after the event's other listeners. Unlike `on()`, its
+     * listener runs before `emit()` returns.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param listener The function called with the event's values.
+     * @returns The component, for chaining.
+     */
+    addListener(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Add a listener, after the event's other listeners.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    on(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Add a listener before the event's other listeners.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    prependListener(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Add a listener called for the event's next emitting only, then removed.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    once(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Add a listener called for the event's next emitting only, then removed; it is placed before the event's other
+     * listeners.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    prependOnceListener(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Add a listener called for the event's next emittings, then removed.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param timesToListen The number of emittings the listener is called for.
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    many(event: string | symbol | event[], timesToListen: number, listener: ListenerFn): this;
+    /**
+     * Add a listener called for the event's next emittings, then removed; it is placed before the event's other
+     * listeners.
+     * @param event The event: a name (`'order.paid'`, the parts separated by dots, with the wildcards `*` for one part
+     * and `**` for any parts) or the parts as an array (`['order', 'paid']`). A symbol is an event of
+     * its own (matched by the wildcard `*` as a name of one part).
+     * @param timesToListen The number of emittings the listener is called for.
+     * @param listener The function called with the event's values, asynchronously after the emitting (in a later turn of
+     * the event loop); its result (or the promise it returns) is collected by `emitRequest()`.
+     * @returns The component, for chaining.
+     */
+    prependMany(event: string | symbol | event[], timesToListen: number, listener: ListenerFn): this;
+    /**
+     * Add a listener of every event, called synchronously at the emitting, before the event's own listeners.
+     * @param listener The function called with the event name, then the event's values.
+     * @returns The component, for chaining.
+     */
+    onAny(listener: EventAndListener): this;
+    /**
+     * Add a listener of every event, before the other listeners of every event, called synchronously at the emitting.
+     * @param listener The function called with the event name, then the event's values.
+     * @returns The component, for chaining.
+     */
+    prependAny(listener: EventAndListener): this;
+    /**
+     * Remove a listener of every event added by `onAny()` or `prependAny()`.
+     * @param listener The listener to remove.
+     * @returns The component, for chaining.
+     */
+    offAny(listener: ListenerFn): this;
+    /**
+     * Remove a listener of an event, as `off()`.
+     * @param event The event the listener was added for.
+     * @param listener The listener to remove.
+     * @returns The component, for chaining.
+     */
+    removeListener(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Remove a listener of an event; nothing happens when it was not added.
+     * @param event The event the listener was added for.
+     * @param listener The listener to remove.
+     * @returns The component, for chaining.
+     */
+    off(event: string | symbol | event[], listener: ListenerFn): this;
+    /**
+     * Remove the listeners of an event, or all the listeners.
+     * @param event The event whose listeners are removed; all the listeners when omitted.
+     * @returns The component, for chaining.
+     */
+    removeAllListeners(event?: string | symbol | event[] | undefined): this;
+    /**
+     * Set the number of listeners of one event above which a possible memory leak is warned of (the
+     * `maxListeners` option, 11 by default); the listeners are never limited.
+     * @param n The number, 0 for no warning.
+     */
+    setMaxListeners(n: number): void;
+    /**
+     * The number of listeners of one event above which a possible memory leak is warned of.
+     * @returns The number, 0 for no warning.
+     */
+    getMaxListeners(): number;
+    /**
+     * The events having listeners, in no guaranteed order.
+     * @param nsAsArray Return each namespaced event as the array of its parts (`['order', 'paid']`) instead of its
+     * name (`'order.paid'`); false by default.
+     * @returns The events.
+     */
+    eventNames(nsAsArray?: boolean | undefined): (string | symbol | event[])[];
+    /**
+     * The number of listeners of an event (the wildcard listeners matching it included), or of every event (the
+     * listeners of `onAny()` excluded).
+     * @param event The event name or its parts as an array; every event when omitted.
+     * @returns The number of listeners.
+     */
+    listenerCount(event?: string | symbol | event[] | undefined): number;
+    /**
+     * The listeners of an event, or of every event.
+     * @param event The event name (the wildcard listeners matching it included), its parts as an array, or a symbol;
+     * every event when omitted (the listeners of `onAny()` excluded).
+     * @returns A copy of the listeners; changing it does not change the listeners.
+     */
+    listeners(event?: string | symbol | event[] | undefined): ListenerFn[];
+    /**
+     * The listeners of every event, added by `onAny()` and `prependAny()`.
+     * @returns A copy of these listeners; changing it does not change the listeners.
+     */
+    listenersAny(): ListenerFn[];
+    /**
+     * Whether an event has listeners (the wildcard listeners matching it included; the listeners of `onAny()`
+     * excluded).
+     * @param event The event name, its parts as an array, or a symbol; any event when omitted.
+     * @returns true when there are listeners.
+     */
+    hasListeners(event?: string | symbol | event[] | undefined): boolean;
+    /**
+     * Destroy the component and initialize it again (same instance): its dependencies are injected again and its
+     * `init()` runs again; its listeners are removed by the teardown. Its configured values are kept.
+     * @returns Resolves once the component is ready again.
+     * @throws {ObjectDestroyedException} When its parent has been destroyed.
+     * @throws {Error} The error of its teardown or of its initialization.
+     */
+    reload(): Promise<void>;
+}