assemblerjs 0.9.7 → 1.0.0

package/dist/index.d.ts

@@ -34,8 +34,9 @@ export declare abstract class AbstractAssemblage {
      * Called when instance of class is disposed.
      *
      * @param { AssemblerContext } context The assembler's context.
+     * @param { Record<string, any> } configuration The configuration object.
      */
-    abstract onDispose?(context: AssemblerContext): void;
+    abstract onDispose?(context: AssemblerContext, configuration?: Record<string, any>): void;
     /**
      * Dispose the assemblage instance.
      */
@@ -46,10 +47,7 @@ export declare abstract class AbstractAssemblage {
     abstract whenReady?(): Promise<void>;
 }
 
-/**
- * `Assembler` abstraction.
- */
-export declare abstract class AbstractAssembler extends AbstractEventManager {
+export declare abstract class AbstractAssembler extends AbstractEventManager implements InjectableResolver, ObjectProvider, TagResolver, LifecycleManager, InjectableRegistrar {
     abstract privateContext: AssemblerContext;
     abstract publicContext: AssemblerContext;
     abstract size: number;
@@ -136,13 +134,14 @@ export declare class Assembler extends EventManager implements AbstractAssembler
      * Build the dependencies tree from an assemblage as entry point.
      *
      * @param { Concrete<T> } entry An assemblage concrete class.
+     * @param { Record<string, any> } configuration Optional configuration to pass to the build process.
      * @returns { T } An instance of `entry` marked as singleton.
      */
-    static build<T>(entry: Concrete<T>): T;
-    protected injectables: Map<Identifier<unknown>, Injectable<unknown>>;
-    protected objects: Map<string | symbol, unknown>;
-    protected globals: Map<string, any>;
-    private initCache;
+    static build<T>(entry: Concrete<T>, configuration?: Record<string, any>): T;
+    protected injectableManager: InjectableManager;
+    protected objectManager: ObjectManager;
+    protected _hookManager: HookManager;
+    get hookManager(): HookManager;
     /**
      * Context passed to internal classes.
      */
@@ -152,509 +151,745 @@ export declare class Assembler extends EventManager implements AbstractAssembler
      */
     readonly publicContext: AssemblerContext;
     private constructor();
-    /**
-     * Dispose assembler and all its injectables.
-     * Note that injectables' instances will be disposed only if
-     * the are singletons.
+    dispose(): void;
+    register<T>(injection: Injection<T>, instance?: boolean): Injectable<T>;
+    use<T>(identifier: string | symbol, object: T): T;
+    prepareInitHook<T = AbstractAssemblage>(instance: T, configuration?: Record<string, any>): unknown[];
+    has<T>(identifier: Identifier<T> | string | symbol): boolean;
+    require<T>(identifier: Identifier<T> | string | symbol, configuration?: Record<string, any>): T;
+    concrete<T>(identifier: Identifier<T>): Concrete<T> | undefined;
+    tagged(...tags: string[]): unknown[];
+    addGlobal(key: string, value: any): void;
+    /**
+     * Get a global value by key.
      *
-     * Transient instances must be disposed by the user.
+     * @param { string } key The key to get global value.
+     * @returns { any | undefined } The global value or `undefined` if not set.
      */
+    global(key: string): any | undefined;
+    /**
+     * Size of the assembler: number of registered dependencies.
+     */
+    get size(): number;
+}
+
+/**
+ * Assembler public context that provide
+ * access to some useful `Assembler` methods.
+ */
+export declare interface AssemblerContext {
+    has: AbstractAssembler['has'];
+    require: AbstractAssembler['require'];
+    concrete: AbstractAssembler['concrete'];
+    tagged: AbstractAssembler['tagged'];
+    global: AbstractAssembler['global'];
+    dispose: AssemblerDispose;
+    on: AbstractAssembler['on'];
+    once: AbstractAssembler['once'];
+    off: AbstractAssembler['off'];
+    events: AbstractAssembler['channels'];
+}
+
+/**
+ * `Assembler` dispose method type.
+ */
+export declare type AssemblerDispose = AbstractAssembler['dispose'];
+
+/**
+ * Assembler private context that provide
+ * access to some `Assembler` methods
+ * used internally.
+ */
+declare interface AssemblerPrivateContext extends AssemblerContext {
+    register: AbstractAssembler['register'];
+    use: AbstractAssembler['use'];
+    prepareInitHook: AbstractAssembler['prepareInitHook'];
+    addGlobal: AbstractAssembler['addGlobal'];
+    emit: AbstractAssembler['emit'];
+    addChannels: AbstractAssembler['addChannels'];
+    removeChannels: AbstractAssembler['removeChannels'];
+}
+
+/**
+ * Check at given interval if a property is defined and truthy to call an async method.
+ *
+ * @param { string } property The name of the class proprty to wait for.
+ * @param { number | undefined } interval The interval in milliseconds at which the value is checked (defaults to 25 milliseconds).
+ * @returns { Promise<void> } A promise that calls the original method when resolving.
+ *
+ * @deprecated This method is deprecated in `assemblerjs` package. Use the same method from `@assemblerjs/core` package.
+ */
+export declare const Await: (property: string, interval?: number) => MethodDecorator;
+
+/**
+ * Injectable binds a concrete class to an abstract class as identifier without configuration.
+ */
+declare type BaseInjection<T> = Tuple<[Abstract<T>, Concrete<T>]>;
+
+/**
+ * Describes a buildable object.
+ */
+declare interface Buildable<T> {
+    identifier: Identifier<T>;
+    concrete: Concrete<T>;
+    instance?: T;
+    configuration: Record<string, any>;
+}
+
+/**
+ * Injection binds a concrete class to itself as identifier
+ * and provides a configuration object that will be passed to context.
+ */
+declare type ConcreteConfiguredInjection<T> = Tuple<[
+Concrete<T>,
+Record<string, any>
+]>;
+
+/**
+ * Injectable binds a conrete class to itself as identifier.
+ */
+declare type ConcreteInjection<T> = Tuple<[Concrete<T>]>;
+
+/**
+ * Injects the injectable's configuration object.
+ * @returns A parameter decorator
+ */
+export declare const Configuration: (param: void) => ParameterDecorator;
+
+/**
+ * Injectable binds a concrete class to an abstract class as identifier
+ * and provides a configuration object that will be passed to context.
+ */
+declare type ConfiguredInjection<T> = Tuple<[
+Abstract<T>,
+Concrete<T>,
+Record<string, any>
+]>;
+
+/**
+ * A custom decorator that adds a function called after the original constructor
+ * and that can wrap an `Assemblage` with its own parameters decorator (e.g. @Use, @Context, ...).
+ * The decorator can be placed above or below the `Assemblage` decorator.
+ * The `definition` optional parameter allows passing a configuration object to the decorator.
+ *
+ * @template TDefinition The type of the definition/configuration object
+ * @param fn A function to execute after `super`. Do not use arrow function here if access to `this` is required.
+ * @param definition The configuration object to pass to the callback function
+ * @returns A ClassDecorator
+ */
+export declare const ConstructorDecorator: <TDefinition extends ObjectLiteral = ObjectLiteral>(fn?: ConstructorDecoratorCallback<any, TDefinition>, definition?: TDefinition) => <TConstructor extends new (...args: any[]) => any>(Base: TConstructor) => TConstructor;
+
+/**
+ * Type for the callback function that will be executed after the constructor.
+ * @template TInstance The type of the class instance
+ * @template TDefinition The type of the definition/configuration object
+ */
+export declare type ConstructorDecoratorCallback<TInstance = any, TDefinition extends ObjectLiteral = ObjectLiteral> = (this: TInstance, definition?: TDefinition) => void;
+
+/**
+ * Type for the decorator function.
+ */
+export declare type ConstructorDecoratorFunction = <T extends new (...args: any[]) => any>(target: T) => T;
+
+/**
+ * Injects the injectable's public context.
+ * @returns A parameter decorator
+ */
+export declare const Context: (param: void) => ParameterDecorator;
+
+/**
+ * Create a custom decorator that adds a function called after the original constructor
+ * and that can wrap an `Assemblage` with its own parameters decorator (e.g. @Use, @Context, ...).
+ * The decorator can be placed above or below the `Assemblage` decorator.
+ * The `definition` optional parameter allows passing a configuration object to the decorator.
+ *
+ * @template TInstance The type of the class instance (for type-safe access to `this`)
+ * @template TDefinition The type of the definition/configuration object
+ * @param fn A function to execute after `super`. Do not use arrow function here if access to `this` is required.
+ * @returns A decorator function that accepts an optional definition and returns a ClassDecorator
+ *
+ * @example
+ * ```typescript
+ * // Define your decorator with typed definition
+ * interface LoggerConfig {
+ *   prefix: string;
+ *   enabled: boolean;
+ * }
+ *
+ * const Logger = createConstructorDecorator<MyClass, LoggerConfig>(function(config) {
+ *   // `this` is typed as MyClass
+ *   this.logPrefix = config?.prefix || 'LOG';
+ * });
+ *
+ * @Logger({ prefix: 'APP', enabled: true })
+ * @Assemblage()
+ * class MyClass implements AbstractAssemblage {
+ *   logPrefix?: string;
+ * }
+ * ```
+ */
+export declare const createConstructorDecorator: <TInstance = any, TDefinition extends ObjectLiteral = ObjectLiteral>(fn?: ConstructorDecoratorCallback<TInstance, TDefinition>) => DecoratorFactory<TDefinition>;
+
+/**
+ * Legacy decorator factory - kept for backward compatibility.
+ * @deprecated Use the new decorators from simple-decorators.ts
+ */
+export declare const createParamIndexDecorator: (key: string) => () => ParameterDecorator;
+
+/**
+ * Manually decorate a class to be an `Assemblage`.
+ *
+ * @param { Concrete<T> } target The class to decorate.
+ * @param { AssemblageDefinition } definition Definition of the assemblage that provides injections, etc.
+ * @returns
+ */
+export declare const decorateAssemblage: <T>(target: Concrete<T>, definition?: AssemblageDefinition) => Concrete<T>;
+
+/**
+ * Legacy function for backward compatibility with constructor-decorator.
+ * @param identifier The identifier of the global object to inject
+ * @param target The target class
+ * @param index The parameter index
+ */
+export declare const decorateGlobal: (identifier: string | symbol, target: any, index: number) => void;
+
+/**
+ * Legacy function for backward compatibility with constructor-decorator.
+ * @param identifier The identifier of the object to inject
+ * @param target The target class
+ * @param index The parameter index
+ */
+export declare const decorateUse: (identifier: string | symbol, target: any, index: number) => void;
+
+/**
+ * Type for a function that creates a decorator.
+ * @template TDefinition The type of the definition/configuration object
+ */
+export declare type DecoratorFactory<TDefinition extends ObjectLiteral = ObjectLiteral> = (definition?: TDefinition) => ConstructorDecoratorFunction;
+
+/**
+ * Handler function for custom decorator logic in constructor-decorator.
+ * @param value The value stored for this parameter (e.g., identifier for Use/Global)
+ * @param target The target class being decorated
+ * @param index The parameter index
+ */
+export declare type DecoratorHandler = (value: any, target: any, index: number) => void;
+
+/**
+ * Metadata about a registered decorator.
+ */
+declare interface DecoratorMetadata_2 {
+    name: string;
+    valueType: 'single' | 'array' | 'map';
+    handler?: DecoratorHandler;
+}
+
+/**
+ * Injects the injectable's definition object.
+ * @returns A parameter decorator
+ */
+export declare const Definition: (param: void) => ParameterDecorator;
+
+/**
+ * Injects the injectable's dispose function.
+ * @returns A parameter decorator
+ */
+export declare const Dispose: (param: void) => ParameterDecorator;
+
+/**
+ * `EventChannel` extends `string`.
+ */
+export declare type EventChannel = string;
+
+/**
+ * Describes a list of event channels as Record<EventChannel, string>
+ */
+export declare type EventChannelList = Record<EventChannel, string>;
+
+export declare class EventManager implements AbstractEventManager {
+    private readonly listeners;
+    private readonly onceListeners;
+    private readonly channelCache;
+    readonly channels: Set<string>;
+    constructor(...allowedChannels: string[]);
     dispose(): void;
+    addChannels(...channels: string[]): EventManager;
+    removeChannels(...channels: string[]): EventManager;
+    on(channel: string, callback: Listener): EventManager;
+    once(channel: string, callback: Listener): EventManager;
+    off(channel: string, callback?: Listener): EventManager;
+    emit(channel: string, ...args: any[]): EventManager;
+    private run;
+    private cleanChannel;
+}
+
+export declare const getAssemblageContext: <T>(target: Concrete<T> | Function) => AssemblerContext;
+
+export declare const getAssemblageDefinition: <T>(target: Concrete<T>) => AssemblageDefinition;
+
+/**
+ * Gets all decorated parameter indexes for registered decorators.
+ * Dynamically retrieves indexes for all decorators registered in ParameterDecoratorFactory.
+ * @param target The concrete class to inspect
+ * @returns Object with indexes for each decorator type
+ */
+export declare const getDecoratedParametersIndexes: <T>(target: Concrete<T>) => ParametersDecoratorsIndexes;
+
+/**
+ * Generic function to get parameter indexes for a specific decorator.
+ * @param decoratorName The name of the decorator (e.g., 'Context', 'Use', 'Global')
+ * @param concrete The concrete class to get indexes from
+ * @returns Array of parameter indexes
+ */
+export declare const getParameterIndexes: <T>(decoratorName: string, concrete: Concrete<T>) => number[];
+
+/**
+ * Generic function to get parameter values for a specific decorator.
+ * @param decoratorName The name of the decorator (e.g., 'Context', 'Use', 'Global')
+ * @param concrete The concrete class to get values from
+ * @returns The stored values (type depends on decorator's valueType configuration)
+ */
+export declare const getParameterValues: <T, V = any>(decoratorName: string, concrete: Concrete<T>) => V;
+
+/**
+ * Generates the reflection key for parameter index based on decorator name.
+ * Must match the format used by ParameterDecoratorFactory.
+ */
+export declare const getParamIndexKey: (decoratorName: string) => string;
+
+/**
+ * Generates the reflection key for parameter value based on decorator name.
+ * Must match the format used by ParameterDecoratorFactory.
+ */
+export declare const getParamValueKey: (decoratorName: string) => string;
+
+/**
+ * Injects a global object by its identifier.
+ * @param identifier The identifier of the global object to inject
+ * @returns A parameter decorator
+ */
+declare const Global_2: (param: string | symbol) => ParameterDecorator;
+export { Global_2 as Global }
+
+declare class HookManager {
+    static callHook: <T>(assemblage: Concrete<T> | T, name: string, context?: AssemblerContext, configuration?: Record<string, any>) => Promise<void>;
+    static callHookImmediate: <T>(assemblage: Concrete<T> | T, name: string, context?: AssemblerContext, configuration?: Record<string, any>) => void;
+    private initCache;
+    prepareInitHook<T = any>(instance: T, configuration?: Record<string, any>): unknown[];
+    callInitHooks(context: AssemblerContext): void;
+    callInitedHooks(context: AssemblerContext): void;
+    clearCache(): void;
+    getCache(): {
+        instance: any;
+        configuration?: Record<string, any>;
+    }[];
+}
+
+/**
+ * An identifier can be an abstract or a concrete class.
+ */
+export declare type Identifier<T> = Class<T>;
+
+/**
+ * Represents an injectable assemblage that can be built into instances.
+ * Handles dependency resolution, configuration management, and lifecycle.
+ */
+declare class Injectable<T> implements AbstractInjectable<T> {
+    readonly privateContext: AssemblerPrivateContext;
+    readonly publicContext: AssemblerContext;
+    /** Unique identifier for this injectable. */
+    readonly identifier: Identifier<T> | string | symbol;
+    /** The concrete class to instantiate. */
+    readonly concrete: Concrete<T>;
+    /** Base configuration for this injectable. */
+    readonly configuration: Record<string, any>;
+    /** Merged configuration used during build (base + runtime). */
+    private mergedConfiguration?;
+    /** Cached definition to avoid repeated metadata lookups. */
+    private cachedDefinition?;
+    /** Cached injections to avoid repeated definition access. */
+    private cachedInjections?;
+    /** Cached objects to avoid repeated definition access. */
+    private cachedObjects?;
+    /** Cached tags to avoid repeated definition access. */
+    private cachedTags?;
+    /** Cached events to avoid repeated definition access. */
+    private cachedEvents?;
+    /** Cached globals to avoid repeated definition access. */
+    private cachedGlobals?;
+    private dependenciesIds;
+    protected singletonInstance: T | undefined;
+    private builder;
+    static of<TNew>(buildable: Buildable<TNew>, privateContext: AssemblerPrivateContext, publicContext: AssemblerContext): Injectable<TNew>;
+    private constructor();
     /**
-     * Recursively register an `Injection` tuple and its inner injected dependencies.
-     *
-     * @param { Injection<T> } injection The injection tuple to register.
-     * @param { boolean | undefined } instance Set to `true` if the injection binds an instance
-     * to an identifier (defaults to `false`).
-     * @returns { Injectable<T> } An injectable of type `T`.
+     * Dispose the injectable by deleting its singleton if exists
+     * and deleting all injectable's properties.
      */
-    register<T>(injection: Injection<T>, instance?: boolean): Injectable<T>;
+    dispose(): void;
     /**
-     * Register a string or symbol identifier with an object.
-     *
-     * @param { string | symbol } identifier The identifier to register.
-     * @param { T } object The object to use with the identifier.
-     * @returns { T } The object.
-     *
-     * @example
-     * ```typescript
-     * import express from 'express';
+     * Instantiate the assemblage.
      *
-     * @Assemblage({
-     *   use: [
-     *     ['express', express]
-     *   ]
-     * });
-     * class MyAssemblage implements AbstractAssemblage {
-     *   constructor(@Use('express) private express) {
-     *     // Use express.
-     *   }
-     * }
-     * ```
+     * @param { Record<string, any> } [configuration] Optional configuration to pass to
+     * the assemblage.
+     * @returns { T } The assemblage instance.
      */
-    use<T>(identifier: string | symbol, object: T): T;
+    build(configuration?: Record<string, any>): T;
     /**
-     * Cache an instance to be inited with `onInit` hook
-     * when the dependency tree will be fully resolved.
-     *
-     * @param { T = AbstractAssemblage } instance The built instance.
-         * @param { Record<string, any> | undefined } configuration The configuration object.
-         * @returns { unknown[] } The instances to be inited as this point.
-         */
-     prepareInitHook<T = AbstractAssemblage>(instance: T, configuration?: Record<string, any>): unknown[];
-     /**
-      * Check if `Assembler` has given identifier registered.
-      *
-      * @param { Identifier<T> | string | symbol } identifier An abstract or concrete class,
-      * or a string or symbol as identifier.
-      * @returns { boolean } `true` if dependency has been registered.
-      */
-     has<T>(identifier: Identifier<T> | string | symbol): boolean;
-     /**
-      * Get or instantiate an assemblage for given identifier.
-      *
-      * @param { Identifier<T> | string | symbol } identifier The identifier to get instance from.
-      * @param { Record<string, any> | undefined } configuration Optional configuration
-      * object to pass to a transient assemblage's constructor.
-      * @returns { T } An instance of Concrete<T>.
-      */
-     require<T>(identifier: Identifier<T> | string | symbol, configuration?: Record<string, any>): T;
-     /**
-      * Return a `Concrete` class for given identifier.
-      *
-      * @param { Identifier<T> } identifier The dentifier to get concrete class from.
-      * @returns { Concrete<T> | undefined } A concrete class or `undefinedù if injectable is not set.
-      */
-     concrete<T>(identifier: Identifier<T>): Concrete<T> | undefined;
-     /**
-      * Require dependencies by tag passed in assemblage's definition.
-      *
-      * @param { string[] } tags The tags to get dependencies.
-      * @returns { unknown[] } An array of instances for the given tags. If registered
-      * identifier is not marked as 'singleton', will resolve in a new instance.
-      */
-     tagged(...tags: string[]): unknown[];
-     addGlobal(key: string, value: any): void;
-     /**
-      * Get a global value by key.
-      *
-      * @param { string } key The key to get global value.
-      * @returns { any | undefined } The global value or `undefined` if not set.
-      */
-     global(key: string): any | undefined;
-     /**
-      * Size of the assembler: number of registered dependencies.
-      */
-     get size(): number;
-    }
-
-    /**
-     * Assembler public context that provide
-     * access to some useful `Assembler` methods.
-     */
-    export declare interface AssemblerContext {
-        has: AbstractAssembler['has'];
-        require: AbstractAssembler['require'];
-        concrete: AbstractAssembler['concrete'];
-        tagged: AbstractAssembler['tagged'];
-        global: AbstractAssembler['global'];
-        dispose: AssemblerDispose;
-        on: AbstractAssembler['on'];
-        once: AbstractAssembler['once'];
-        off: AbstractAssembler['off'];
-        events: AbstractAssembler['channels'];
-    }
-
-    /**
-     * `Assembler` dispose method type.
-     */
-    export declare type AssemblerDispose = AbstractAssembler['dispose'];
-
-    /**
-     * Assembler private context that provide
-     * access to some `Assembler` methods
-     * used internally.
-     */
-    declare interface AssemblerPrivateContext extends AssemblerContext {
-        register: AbstractAssembler['register'];
-        use: AbstractAssembler['use'];
-        prepareInitHook: AbstractAssembler['prepareInitHook'];
-        addGlobal: AbstractAssembler['addGlobal'];
-        emit: AbstractAssembler['emit'];
-        addChannels: AbstractAssembler['addChannels'];
-        removeChannels: AbstractAssembler['removeChannels'];
-    }
-
-    /**
-     * Check at given interval if a property is defined and truthy to call an async method.
-     *
-     * @param { string } property The name of the class proprty to wait for.
-     * @param { number | undefined } interval The interval in milliseconds at which the value is checked (defaults to 25 milliseconds).
-     * @returns { Promise<void> } A promise that calls the original method when resolving.
-     *
-     * @deprecated This method is deprecated in `assemblerjs` package. Use the same method from `@assemblerjs/core` package.
+     * Sets the singleton instance for this injectable.
+     * Used internally by resolution strategies.
+     * @param instance The singleton instance.
+     * @param mergedConfiguration Optional merged configuration to store.
      */
-    export declare const Await: (property: string, interval?: number) => MethodDecorator;
-
+    setSingletonInstance(instance: T, mergedConfiguration?: Record<string, any>): void;
     /**
-     * Injectable binds a concrete class to an abstract class as identifier without configuration.
+     * Metadatas passed in assemblage's definition or in its parent definition.
+     * Cached to avoid repeated reflection calls.
      */
-    declare type BaseInjection<T> = Tuple<[Abstract<T>, Concrete<T>]>;
-
+    get definition(): AssemblageDefinition;
     /**
-     * Describes a buildable object.
+     * `true` if assemblage is a singleton.
      */
-    declare interface Buildable<T> {
-        identifier: Identifier<T>;
-        concrete: Concrete<T>;
-        instance?: T;
-        configuration: Record<string, any>;
-    }
-
+    get isSingleton(): boolean;
     /**
-     * Injection binds a concrete class to itself as identifier
-     * and provides a configuration object that will be passed to context.
+     * Injectable assemblage's dependencies passed as 'constructor' parameters.
      */
-    declare type ConcreteConfiguredInjection<T> = Tuple<[
-    Concrete<T>,
-    Record<string, any>
-    ]>;
-
+    get dependencies(): (Identifier<unknown> | any)[];
     /**
-     * Injectable binds a conrete class to itself as identifier.
+     * The singleton instance if this `Injectable` wraps a singleton assemblage.
      */
-    declare type ConcreteInjection<T> = Tuple<[Concrete<T>]>;
-
+    get singleton(): T | undefined;
     /**
-     * Injects the assemblage's configuration object.
+     * Injectable assemblage's own injections defined in its decorator's definition.
      */
-    export declare const Configuration: () => ParameterDecorator;
-
+    get injections(): Injection<unknown>[];
+    /**
+     * Injectable assemblage's own objects (e.g. instances) injections defined in its decorator's definition.
+     */
+    get objects(): InstanceInjection<unknown>[];
+    /**
+     * Tags passed in assemblage's definition.
+     */
+    get tags(): string[];
+    /**
+     * Global injections passed in assemblage's definition.
+     * These injections are available in all assemblages and can be used
+     * to provide global values, services or utilities.
+     */
+    get globals(): Record<string, any> | undefined;
     /**
-     * Injectable binds a concrete class to an abstract class as identifier
-     * and provides a configuration object that will be passed to context.
+     * Event channels passed in assemblage's definition.
      */
-    declare type ConfiguredInjection<T> = Tuple<[
-    Abstract<T>,
-    Concrete<T>,
-    Record<string, any>
-    ]>;
+    get events(): string[];
+}
+
+declare class InjectableManager {
+    private injectables;
+    private privateContext;
+    private publicContext;
+    private singletonStrategy;
+    private transientStrategy;
+    setContexts(privateContext: AssemblerPrivateContext, publicContext: AssemblerContext): void;
+    register<T>(injection: Injection<T>, instance?: boolean): Injectable<T>;
+    has<T>(identifier: Identifier<T>): boolean;
+    require<T>(identifier: Identifier<T>, configuration?: Record<string, any>): T;
+    concrete<T>(identifier: Identifier<T>): any | undefined;
+    tagged(...tags: string[]): unknown[];
+    dispose(): void;
+    get size(): number;
+}
+
+declare interface InjectableRegistrar {
+    register<T>(injection: Injection<T>, instance?: boolean): Injectable<T>;
+}
+
+/**
+ * `Assembler` abstraction.
+ */
+declare interface InjectableResolver {
+    has<T>(identifier: Identifier<T>): boolean;
+    require<T>(identifier: Identifier<T> | string | symbol, configuration?: Record<string, any>): T;
+    concrete<T>(identifier: Identifier<T>): Concrete<T> | undefined;
+}
+
+/**
+ * A generic injection tuple.
+ */
+declare type Injection<T> = BaseInjection<T> | ConfiguredInjection<T> | ConcreteInjection<T> | ConcreteConfiguredInjection<T>;
 
+/**
+ * Injectable binds an instance of a class to an identifier (abstract or concrete).
+ */
+declare type InstanceInjection<T> = Tuple<[Identifier<T> | string | symbol, T]>;
+
+/**
+ * Check if a given class is an `Assemblage`.
+ *
+ * @param { Concrete<T> } target The class to test.
+ * @returns `true` if the class is an assemblage.
+ */
+export declare const isAssemblage: <T>(target: Concrete<T>) => boolean;
+
+declare interface LifecycleManager {
+    prepareInitHook<T = AbstractAssemblage>(instance: T, configuration?: Record<string, any>): unknown[];
+}
+
+/**
+ * Describes a listener type as a function taking any number of arguments and returning `void`.
+ */
+export declare type Listener = (...args: any[]) => void | Promise<void>;
+
+export declare class ListenerCollection implements AbstractListenerCollection {
+    /**
+     * Class is indexable by `EventChannel`.
+     */
+    [key: string]: Listener[] | any;
+    /**
+     * Internal listeners `Object`.
+     */
+    readonly collection: Record<EventChannel, Array<Listener>>;
+    constructor();
     /**
-     * A custom decorator that adds a function called after the original constructor
-     * and that can wrap an `Assemblage` with its own parameters decorator (e.g. @Use, @Context, ...).
-     * Note that it must be placed before the `Assemnblage` decorator.
-     * The `definition` optional parameter allows passing a configuration object to the decorator.
+     * Clean up the collection by removing all listeners and channels
+     * and deleting listeners private property.
+     */
+    dispose(): void;
+    /**
+     * Add a listener to the collection.
      *
-     * @param { function(definition?: ObjectLiteral): void | undefined } fn A function to execute after `super`.
-     * Do not use arrow function here if access to `this` is required.
-     * @param { boolean | undefined } asAssemblage If `true` decorate the class as an assemblage (defaults to `true`).
-     * @returns A new decorator.
+     * @param { EventChannel } channel The channel to add the listener to.
+     * @param { Listener } listener The callback function to run when the event is emitted.
+     * @returns { ListenerCollection } This collection.
      */
-    export declare const ConstructorDecorator: <T extends ObjectLiteral>(fn?: (definition?: T) => void, definition?: T) => any;
-
+    add(channel: EventChannel, listener: Listener): ListenerCollection;
     /**
-     * Injects the Assembler's context.
+     * Add a listener to the collection.
+     *
+     * @param { Tuple<EventChannel, Listener> } tuple The channel and its listener in a tuple.
+     * @returns { ListenerCollection } This collection.
      */
-    export declare const Context: () => ParameterDecorator;
-
+    add(tuple: Tuple<[EventChannel, Listener]>): ListenerCollection;
     /**
-     * Create a custom decorator that adds a function called after the original constructor
-     * and that can wrap an `Assemblage` with its own parameters decorator (e.g. @Use, @Context, ...).
-     * Note that it must be placed before the `Assemblage` decorator.
-     * The `definition` optional parameter allows passing a configuration object to the decorator.
+     * Removes a listener or all listeners for a given channel.
+     * If the channel or the provided listener does not exist, fails silently.
      *
-     * @param { function(definition?: ObjectLiteral): void | undefined } fn A function to execute after `super`.
-     * Do not use arrow function here if access to `this` is required.
-     * @returns A new decorator.
+     * @param { EventChannel } channel The channel the listener is listening to.
+     * @param { Listener } listener The listener to remove. If not provided, remove all listeners for given channel.
+     * @returns { ListenerCollection } This collection.
      */
-    export declare const createConstructorDecorator: <T extends ObjectLiteral>(fn?: (definition?: T) => void) => any;
-
+    remove(channel: string, listener?: Listener): ListenerCollection;
     /**
-     * Manually decorate a class to be an `Assemblage`.
+     * Checks if the collection includes a specific channel or listener.
      *
-     * @param { Concrete<T> } target The class to decorate.
-     * @param { AssemblageDefinition } definition Definition of the assemblage that provides injections, etc.
-     * @returns
+     * @param { EventChannel | Listener } value The channel or the listener to find in the collection.
+     * @returns { boolean } true if the collection includes this channel / this listener,
+     * false if not.
      */
-    export declare const decorateAssemblage: <T>(target: Concrete<T>, definition?: AssemblageDefinition) => Concrete<T>;
-
+    has(value: EventChannel): boolean;
+    has(value: Listener): boolean;
     /**
-     * Decorator as a wrapper function.
+     * Get a specific channel listeners array or a specific listener channels array.
+     *
+     * @param { EventChannel | Listener } value The channel or the listener to find in the collection.
+     * @returns { EventChannel[] | Listener[] } An array of channels or listeners.
      */
-    export declare const decorateGlobal: (identifier: string | symbol, target: any, index: number) => void;
-
+    get(value: EventChannel): Listener[];
+    get(value: Listener): EventChannel[];
     /**
-     * Decorator as a wrapper function.
+     * Clear the entire collection.
+     *
+     * @returns { ListenerCollection } This collection.
      */
-    export declare const decorateUse: (identifier: string | symbol, target: any, index: number) => void;
-
+    clear(): ListenerCollection;
     /**
-     * Injects the assemblage's definition object.
+     * The listeners of this collection flatten in a single array.
      */
-    export declare const Definition: () => ParameterDecorator;
-
+    get listeners(): Listener[];
+    /**
+     * The listeners collection channels.
+     */
+    get channels(): EventChannel[];
+    /**
+     * Returns the total listeners length.
+     */
+    get length(): number;
     /**
-     * Injects the Assembler's 'dispose' method.
-     */
-    export declare const Dispose: () => ParameterDecorator;
-
-    /**
-     * `EventChannel` extends `string`.
-     */
-    export declare type EventChannel = string;
-
-    /**
-     * Describes a list of event channels as Record<EventChannel, string>
-     */
-    export declare type EventChannelList = Record<EventChannel, string>;
-
-    export declare class EventManager implements AbstractEventManager {
-        private readonly listeners;
-        private readonly onceListeners;
-        readonly channels: Set<string>;
-        constructor(...allowedChannels: string[]);
-        dispose(): void;
-        addChannels(...channels: string[]): EventManager;
-        removeChannels(...channels: string[]): EventManager;
-        on(channel: string, callback: Listener): EventManager;
-        once(channel: string, callback: Listener): EventManager;
-        off(channel: string, callback?: Listener): EventManager;
-        emit(channel: string, ...args: any[]): EventManager;
-        private run;
-        private cleanChannel;
-    }
+     * Allows iterating over listeners in specific channel with 'for... of...' loop.
+     *
+     * @returns { Listener } A listener function.
+     *
+     * @example
+     * // Iterates listeners in a specific channel.
+     * for (const listener of myListenerCollection) {
+     *   // Calls the registered listener.
+     *   listener();
+     * }
+     */
+    [Symbol.iterator](): Iterator<EventChannel>;
+}
 
-    export declare const getAssemblageContext: <T>(target: Concrete<T> | Function) => AssemblerContext;
+export declare interface ObjectLiteral {
+    [key: string]: any;
+}
 
-    export declare const getAssemblageDefinition: <T>(target: Concrete<T>) => AssemblageDefinition;
+declare class ObjectManager {
+    private objects;
+    private globals;
+    use<T>(identifier: string | symbol, object: T): T;
+    has(identifier: string | symbol): boolean;
+    require<T>(identifier: string | symbol): T;
+    addGlobal(key: string, value: any): void;
+    global(key: string): any | undefined;
+}
+
+declare interface ObjectProvider {
+    use<T>(identifier: string | symbol, object: T): T;
+    global(key: string): any | undefined;
+    addGlobal(key: string, value: any): void;
+}
+
+/**
+ * Marks a constructor parameter as optional.
+ * If the dependency is not available, the provided default value (or undefined) will be injected.
+ *
+ * @param defaultValue Optional default value to use when the dependency is not available.
+ *                     If not provided, undefined will be injected.
+ *
+ * @example
+ * // Without default value - injects undefined if not available
+ * class MyService {
+ *   constructor(
+ *     private logger: Logger,              // Required
+ *     @Optional() private cache?: Cache    // Optional - undefined if not available
+ *   ) {}
+ * }
+ *
+ * @example
+ * // With default value
+ * class MyService {
+ *   constructor(
+ *     @Optional(new ConsoleLogger()) private logger: Logger,
+ *     @Optional(null) private cache: Cache | null
+ *   ) {}
+ * }
+ */
+export declare const Optional: (param: any) => ParameterDecorator;
 
-    export declare const getDecoratedParametersIndexes: <T>(target: Concrete<T>) => ParametersDecoratorsIndexes;
+/**
+ * Configuration for creating a parameter decorator.
+ */
+export declare interface ParameterDecoratorConfig {
+    /** The name of the decorator (e.g., 'Logger', 'Database') */
+    name: string;
+    /** How parameter values are stored */
+    valueType?: 'single' | 'array' | 'map';
+    /** The resolver class for this decorator */
+    resolver: new () => ParameterResolver;
+    /** Optional handler for custom decoration logic (e.g., for Use/Global decorators) */
+    handler?: DecoratorHandler;
+}
 
+/**
+ * Factory for creating parameter decorators.
+ * Decorators are responsible for registering their own resolvers.
+ * This eliminates boilerplate code and ensures consistency across all decorators.
+ */
+export declare class ParameterDecoratorFactory {
+    private static registeredDecorators;
     /**
-     * Injects an object passed with `string` or `symbol` identifier.
+     * Creates a parameter decorator.
+     * Note: Resolvers must be registered separately by the decorator implementation.
+     * @param config The decorator configuration
+     * @returns A parameter decorator function
      */
-    declare const Global_2: (identifier: string | symbol) => ParameterDecorator;
-    export { Global_2 as Global }
+    static create<T>(config: ParameterDecoratorConfig): (param: T) => ParameterDecorator;
+    /**
+     * Creates the actual decorator function.
+     */
+    private static createDecoratorFunction;
+    /**
+     * Validates that a parameter doesn't already have a decorator applied.
+     * @param target The target class
+     * @param index The parameter index
+     * @param currentParamIndex The metadata key for the current decorator being applied
+     * @throws Error if the parameter already has a decorator
+     */
+    private static validateSingleDecoratorPerParameter;
+    /**
+     * Stores parameter data using reflection metadata.
+     */
+    private static storeParameterData;
+    /**
+     * Creates a helper function to get parameter indexes for a decorator.
+     * @param paramIndexKey The reflection key for parameter indexes
+     * @returns A function that retrieves indexes for a concrete class
+     */
+    static createParameterIndexGetter(paramIndexKey: string): <T>(concrete: Concrete<T>) => number[];
+    /**
+     * Creates a helper function to get parameter values for a decorator.
+     * @param paramValueKey The reflection key for parameter values
+     * @param valueType The type of value storage (currently unused but kept for future extensibility)
+     * @returns A function that retrieves values for a concrete class
+     */
+    static createParameterValueGetter(paramValueKey: string, _valueType: 'single' | 'array' | 'map'): <T>(concrete: Concrete<T>) => any;
+    /**
+     * Gets all registered decorator names.
+     * @returns Array of registered decorator names
+     */
+    static getRegisteredDecorators(): string[];
+    /**
+     * Checks if a decorator is registered.
+     * @param name The decorator name
+     * @returns True if registered, false otherwise
+     */
+    static isRegistered(name: string): boolean;
+    /**
+     * Gets metadata for a registered decorator.
+     * @param name The decorator name
+     * @returns The decorator metadata or undefined if not found
+     */
+    static getDecoratorMetadata(name: string): DecoratorMetadata_2 | undefined;
+    /**
+     * Gets the handler for a decorator if it has one.
+     * @param name The decorator name
+     * @returns The handler function or undefined
+     */
+    static getDecoratorHandler(name: string): DecoratorHandler | undefined;
+}
 
+/**
+ * Interface for parameter resolvers that handle different types of injection.
+ */
+declare interface ParameterResolver {
     /**
-     * An identifier can be an abstract or a concrete class.
+     * Resolves a parameter value for a given index.
+     * @param index The parameter index in the constructor.
+     * @param injectable The injectable instance.
+     * @param concrete The concrete class being instantiated.
+     * @param config Optional merged configuration.
+     * @returns The resolved parameter value.
      */
-    export declare type Identifier<T> = Class<T>;
+    resolve(index: number, injectable: AbstractInjectable<any>, concrete: Concrete<any>, config?: Record<string, any>): any;
+}
 
-    declare class Injectable<T> implements AbstractInjectable<T> {
-        readonly privateContext: AssemblerPrivateContext;
-        readonly publicContext: AssemblerContext;
-        readonly identifier: Identifier<T> | string | symbol;
-        readonly concrete: Concrete<T>;
-        readonly configuration: Record<string, any>;
-        private dependenciesIds;
-        private singletonInstance;
-        static of<TNew>(buildable: Buildable<TNew>, privateContext: AssemblerPrivateContext, publicContext: AssemblerContext): Injectable<TNew>;
-        private constructor();
-        /**
-         * Dispose the injectable by deleting its singleton if exists
-         * and deleting all injectable's properties.
-         */
-        dispose(): void;
-        /**
-         * Instantiate the assemblage or get its singleton instance.
-         *
-         * @param { Record<string, any> } [configuration] Optional configuration to pass to
-         * a transient assemblage.
-         * If not provided, the global assemblage's configuration will be used.
-         * If the assemblage is a singleton, this parameter will be ignored.
-         * @returns { T } The assemblage instance.
-         */
-        build(configuration?: Record<string, any>): T;
-        /**
-         * Injectable assemblage's dependencies passed as 'constructor' parameters.
-         */
-        get dependencies(): (Identifier<unknown> | any)[];
-        /**
-         * Metadatas passed in assemblage's definition or in its parent definition.
-         */
-        get definition(): AssemblageDefinition;
-        /**
-         * `true` if assemblage is a singleton.
-         */
-        get isSingleton(): boolean;
-        /**
-         * The singleton instance if this `Injectable` wraps a singleton assemblage.
-         */
-        get singleton(): T | undefined;
-        /**
-         * Injectable assemblage's own injections defined in its decorator's definition.
-         */
-        get injections(): Injection<unknown>[];
-        /**
-         * Injectable assemblage's own objects (e.g. instances) injections defined in its decorator's definition.
-         */
-        get objects(): InstanceInjection<unknown>[];
-        /**
-         * Tags passed in assemblage's definition.
-         */
-        get tags(): string[];
-        /**
-         * Global injections passed in assemblage's definition.
-         * These injections are available in all assemblages and can be used
-         * to provide global services or utilities.
-         */
-        get globals(): Record<string, any> | undefined;
-        /**
-         * Event channels passed in assemblage's definition.
-         */
-        get events(): string[];
-    }
-
-    /**
-     * A generic injection tuple.
-     */
-    declare type Injection<T> = BaseInjection<T> | ConfiguredInjection<T> | ConcreteInjection<T> | ConcreteConfiguredInjection<T>;
-
-    /**
-     * Injectable binds an instance of a class to an identifier (abstract or concrete).
-     */
-    declare type InstanceInjection<T> = Tuple<[Identifier<T> | string | symbol, T]>;
-
-    /**
-     * Check if a given class is an `Assemblage`.
-     *
-     * @param { Concrete<T> } target The class to test.
-     * @returns `true` if the class is an assemblage.
-     */
-    export declare const isAssemblage: <T>(target: Concrete<T>) => boolean;
-
-    /**
-     * Describes a listener type as a function taking any number of arguments and returning `void`.
-     */
-    export declare type Listener = (...args: any[]) => void | Promise<void>;
-
-    export declare class ListenerCollection implements AbstractListenerCollection {
-        /**
-         * Class is indexable by `EventChannel`.
-         */
-        [key: string]: Listener[] | any;
-        /**
-         * Internal listeners `Object`.
-         */
-        readonly collection: Record<EventChannel, Array<Listener>>;
-        constructor();
-        /**
-         * Clean up the collection by removing all listeners and channels
-         * and deleting listeners private property.
-         */
-        dispose(): void;
-        /**
-         * Add a listener to the collection.
-         *
-         * @param { EventChannel } channel The channel to add the listener to.
-         * @param { Listener } listener The callback function to run when the event is emitted.
-         * @returns { ListenerCollection } This collection.
-         */
-        add(channel: EventChannel, listener: Listener): ListenerCollection;
-        /**
-         * Add a listener to the collection.
-         *
-         * @param { Tuple<EventChannel, Listener> } tuple The channel and its listener in a tuple.
-         * @returns { ListenerCollection } This collection.
-         */
-        add(tuple: Tuple<[EventChannel, Listener]>): ListenerCollection;
-        /**
-         * Removes a listener or all listeners for a given channel.
-         * If the channel or the provided listener does not exist, fails silently.
-         *
-         * @param { EventChannel } channel The channel the listener is listening to.
-         * @param { Listener } listener The listener to remove. If not provided, remove all listeners for given channel.
-         * @returns { ListenerCollection } This collection.
-         */
-        remove(channel: string, listener?: Listener): ListenerCollection;
-        /**
-         * Checks if the collection includes a specific channel or listener.
-         *
-         * @param { EventChannel | Listener } value The channel or the listener to find in the collection.
-         * @returns { boolean } true if the collection includes this channel / this listener,
-         * false if not.
-         */
-        has(value: EventChannel): boolean;
-        has(value: Listener): boolean;
-        /**
-         * Get a specific channel listeners array or a specific listener channels array.
-         *
-         * @param { EventChannel | Listener } value The channel or the listener to find in the collection.
-         * @returns { EventChannel[] | Listener[] } An array of channels or listeners.
-         */
-        get(value: EventChannel): Listener[];
-        get(value: Listener): EventChannel[];
-        /**
-         * Clear the entire collction.
-         *
-         * @returns { ListenerCollection } This collection.
-         */
-        clear(): ListenerCollection;
-        /**
-         * The listeners of this collection flatten in a single array.
-         */
-        get listeners(): Listener[];
-        /**
-         * The listeners collection channels.
-         */
-        get channels(): EventChannel[];
-        /**
-         * Returns the total listeners length.
-         */
-        get length(): number;
-        /**
-         * Allows iterating over listeners in specific channel with 'for... of...' loop.
-         *
-         * @returns { Listener } A listener function.
-         *
-         * @example
-         * // Iterates listeners in a specific channel.
-         * for (const listener of myListenerCollection) {
-         *   // Calls the registered listener.
-         *   listener();
-         * }
-         */
-        [Symbol.iterator](): Iterator<EventChannel>;
-    }
-
-    export declare interface ObjectLiteral {
-        [key: string]: any;
-    }
-
-    declare interface ParametersDecoratorsIndexes {
-        Context: number[];
-        Definition: number[];
-        Configuration: number[];
-        Dispose: number[];
-        Use: number[];
-        Global: number[];
-    }
-
-    /**
-     * Internal `Reflect` parameters decorators' indexes in constructor.
-     */
-    export declare enum ReflectParamIndex {
-        Context = "assembler:context.param.index",
-        Dispose = "assembler:dispose.param.index",
-        Definition = "assemblage:definition.param.index",
-        Configuration = "assemblage:configuration.param.index",
-        Use = "assemblage:use.param.index",
-        Global = "assemblage:global.param.index"
-    }
-
-    /**
-     * Internal `Reflect` parameters decorators' values.
-     */
-    export declare enum ReflectParamValue {
-        UseIdentifier = "assemblage:use.param.value",
-        GlobalIdentifier = "assemblage:global.param.value"
-    }
-
-    /**
-     * Injects an object passed with `string` or `symbol` identifier.
-     */
-    export declare const Use: (identifier: string | symbol) => ParameterDecorator;
-
-    export { }
+/**
+ * Dynamic record of parameter decorator indexes.
+ * Keys are decorator names (e.g., 'Context', 'Use', 'Global', etc.)
+ * Values are arrays of parameter indexes where the decorator is applied.
+ */
+declare interface ParametersDecoratorsIndexes {
+    [decoratorName: string]: number[];
+}
+
+declare interface TagResolver {
+    tagged(...tags: string[]): any[];
+}
+
+/**
+ * Injects an object passed with `string` or `symbol` identifier.
+ * @param identifier The identifier of the object to inject
+ * @returns A parameter decorator
+ */
+export declare const Use: (param: string | symbol) => ParameterDecorator;
+
+export { }