@decaf-ts/injectable-decorators 1.16.0 → 1.18.0

package/lib/cjs/index.cjs

@@ -36,7 +36,7 @@ __exportStar(require("./utils.cjs"), exports);
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-exports.VERSION = "1.15.0";
+exports.VERSION = "1.17.0";
 exports.PACKAGE_NAME = "@decaf-ts/injectable-decorators";
 decoration_1.Metadata.registerLibrary(exports.PACKAGE_NAME, exports.VERSION);
 //# sourceMappingURL=index.js.map

package/lib/esm/index.js

@@ -19,7 +19,7 @@ export * from "./utils.js";
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export const VERSION = "1.15.0";
+export const VERSION = "1.17.0";
 export const PACKAGE_NAME = "@decaf-ts/injectable-decorators";
 Metadata.registerLibrary(PACKAGE_NAME, VERSION);
 //# sourceMappingURL=index.js.map

package/lib/types/Injectables.d.cts

@@ -1,4 +1,4 @@
-import { Injectable, InjectablesRegistry } from "./registry.cjs";
+import { Injectable, InjectablesRegistry } from "./registry.d.cts";
 /**
  * @description Central registry for managing injectable dependencies.
  * @summary Static class holding the access to the injectables functions. Provides methods for registering,

package/lib/types/Injectables.d.mts

@@ -1,4 +1,4 @@
-import { Injectable, InjectablesRegistry } from "./registry.js";
+import { Injectable, InjectablesRegistry } from "./registry.d.mts";
 /**
  * @description Central registry for managing injectable dependencies.
  * @summary Static class holding the access to the injectables functions. Provides methods for registering,

package/lib/types/Metadata.d.cts

@@ -1,5 +1,5 @@
 import type { Constructor } from "@decaf-ts/decoration";
-import { InjectOptions } from "./decorators.cjs";
+import { InjectOptions } from "./decorators.d.cts";
 declare module "@decaf-ts/decoration" {
     namespace Metadata {
         function injectables<T extends string | symbol | Constructor>(category?: T): (T extends undefined ? Constructor[] : Constructor) | undefined;

package/lib/types/Metadata.d.mts

@@ -1,5 +1,5 @@
 import type { Constructor } from "@decaf-ts/decoration";
-import { InjectOptions } from "./decorators.js";
+import { InjectOptions } from "./decorators.d.mts";
 declare module "@decaf-ts/decoration" {
     namespace Metadata {
         function injectables<T extends string | symbol | Constructor>(category?: T): (T extends undefined ? Constructor[] : Constructor) | undefined;

package/lib/types/constants.d.cts

@@ -1,4 +1,4 @@
-import { InjectableConfig } from "./decorators.cjs";
+import { InjectableConfig } from "./decorators.d.cts";
 /**
  * @description Constants used for reflection metadata keys in the dependency injection system.
  * @summary Injectables Reflection keys used to store and retrieve metadata about injectable classes and properties.

package/lib/types/constants.d.mts

@@ -1,4 +1,4 @@
-import { InjectableConfig } from "./decorators.js";
+import { InjectableConfig } from "./decorators.d.mts";
 /**
  * @description Constants used for reflection metadata keys in the dependency injection system.
  * @summary Injectables Reflection keys used to store and retrieve metadata about injectable classes and properties.

package/lib/types/decorators.d.cts

@@ -1,4 +1,4 @@
-import { InstanceCallback } from "./types.cjs";
+import { InstanceCallback } from "./types.d.cts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Configuration options for the @injectable decorator.

package/lib/types/decorators.d.mts

@@ -1,4 +1,4 @@
-import { InstanceCallback } from "./types.js";
+import { InstanceCallback } from "./types.d.mts";
 import { Constructor } from "@decaf-ts/decoration";
 /**
  * @description Configuration options for the @injectable decorator.

package/lib/types/index.d.cts

@@ -6,17 +6,17 @@
  *
  * @module injectable-decorators
  */
-export * from "./constants.cjs";
-export * from "./decorators.cjs";
-export * from "./Injectables.cjs";
-export * from "./registry.cjs";
-export * from "./types.cjs";
-export * from "./utils.cjs";
+export * from "./constants.d.cts";
+export * from "./decorators.d.cts";
+export * from "./Injectables.d.cts";
+export * from "./registry.d.cts";
+export * from "./types.d.cts";
+export * from "./utils.d.cts";
 /**
  * @description Current version of the injectable-decorators library.
  * @summary Defined on library build. Holds the library's current version string.
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export declare const VERSION = "1.15.0";
+export declare const VERSION = "1.17.0";
 export declare const PACKAGE_NAME = "@decaf-ts/injectable-decorators";

package/lib/types/index.d.mts

@@ -6,17 +6,17 @@
  *
  * @module injectable-decorators
  */
-export * from "./constants.js";
-export * from "./decorators.js";
-export * from "./Injectables.js";
-export * from "./registry.js";
-export * from "./types.js";
-export * from "./utils.js";
+export * from "./constants.d.mts";
+export * from "./decorators.d.mts";
+export * from "./Injectables.d.mts";
+export * from "./registry.d.mts";
+export * from "./types.d.mts";
+export * from "./utils.d.mts";
 /**
  * @description Current version of the injectable-decorators library.
  * @summary Defined on library build. Holds the library's current version string.
  * @const VERSION
  * @memberOf module:injectable-decorators
  */
-export declare const VERSION = "1.15.0";
+export declare const VERSION = "1.17.0";
 export declare const PACKAGE_NAME = "@decaf-ts/injectable-decorators";

package/lib/types/registry.d.cts

@@ -1,4 +1,4 @@
-import { InjectableOptions } from "./types.cjs";
+import { InjectableOptions } from "./types.d.cts";
 /**
  * @description Type representing either a class constructor or an instance.
  * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.

package/lib/types/registry.d.mts

@@ -1,4 +1,4 @@
-import { InjectableOptions } from "./types.js";
+import { InjectableOptions } from "./types.d.mts";
 /**
  * @description Type representing either a class constructor or an instance.
  * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@decaf-ts/injectable-decorators",
-  "version": "1.16.0",
+  "version": "1.18.0",
   "description": "injectable decorators extension for decorator validation",
   "type": "module",
   "exports": {

package/lib/types/Injectables.d.ts

@@ -1,108 +0,0 @@
-import { Injectable, InjectablesRegistry } from "./registry";
-/**
- * @description Central registry for managing injectable dependencies.
- * @summary Static class holding the access to the injectables functions. Provides methods for registering,
- * retrieving, and building injectable objects.
- * @template T Type of the injectable object
- *
- * @class Injectables
- *
- * @example
- * // Define an injectable class
- * @injectable()
- * class MyService {
- *   doSomething() {
- *     return 'Hello World';
- *   }
- * }
- *
- * // Inject the service into another class
- * class MyComponent {
- *   @inject()
- *   private service!: MyService;
- *
- *   useService() {
- *     return this.service.doSomething();
- *   }
- * }
- *
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Injectables
- *   participant Registry
- *
- *   Client->>Injectables: register(MyService)
- *   Injectables->>Registry: register(MyService)
- *   Registry-->>Injectables: void
- *
- *   Client->>Injectables: get("MyService")
- *   Injectables->>Registry: get("MyService")
- *   Registry-->>Injectables: MyService instance
- *   Injectables-->>Client: MyService instance
- */
-export declare class Injectables {
-    /**
-     * @description Holds the active registry implementation used by the Injectables facade.
-     * @summary Internal static reference that can be swapped via setRegistry to customize how injectables are stored and retrieved.
-     * @type {InjectablesRegistry | undefined}
-     */
-    private static actingInjectablesRegistry?;
-    private constructor();
-    /**
-     * @description Fetches an injectable instance by its registered name.
-     * @summary Retrieves the named {@link Injectable} from the registry. If the injectable is a singleton,
-     * returns the existing instance. Otherwise, creates a new instance.
-     * @template T Type of the injectable object to retrieve
-     * @param {string} name The registered name of the injectable to retrieve
-     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
-     * @return {Injectable<T> | undefined} The injectable instance or undefined if not found
-     */
-    static get<T>(name: symbol | string | {
-        new (...args: any[]): T;
-    }, ...args: any[]): T | undefined;
-    /**
-     * @description Adds a class or object to the injectable registry.
-     * @summary Registers an injectable constructor or instance with the registry, making it available for injection.
-     * @template T Type of the injectable object to register
-     * @param {Injectable<T>} constructor The class constructor or object instance to register
-     * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)
-     * @return {void}
-     */
-    static register<T>(constructor: Injectable<T>, ...args: any[]): void;
-    /**
-     * @description Creates a new instance of an injectable class.
-     * @summary Instantiates an injectable class using its constructor and the provided arguments.
-     * @template T Type of the object to build
-     * @param {symbol} name symbol referencing the injectable
-     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
-     * @return {T} The newly created instance
-     */
-    static build<T>(name: symbol, ...args: any[]): T;
-    /**
-     * @description Replaces the current registry implementation.
-     * @summary Sets a new {@link InjectablesRegistry} implementation, allowing for custom registry behavior.
-     * @param {InjectablesRegistry} operationsRegistry The new implementation of Registry to use
-     * @return {void}
-     */
-    static setRegistry(operationsRegistry: InjectablesRegistry): void;
-    /**
-     * @description Provides access to the current registry instance.
-     * @summary Returns the current {@link InjectablesRegistry} or creates a default one if none exists.
-     * @return {InjectablesRegistry} The current registry instance
-     */
-    private static getRegistry;
-    /**
-     * @description Clears all registered injectables.
-     * @summary Resets the registry to a clean state by creating a new empty registry instance.
-     * @return {void}
-     */
-    static reset(): void;
-    /**
-     * @description Removes specific injectables from the registry based on a pattern.
-     * @summary Selectively resets the registry by removing only the injectables whose names match the provided pattern.
-     * @param {string | RegExp} match A string or regular expression pattern to match against injectable names
-     * @return {void}
-     */
-    static selectiveReset(match: string | RegExp): void;
-}

package/lib/types/Metadata.d.ts

@@ -1,8 +0,0 @@
-import type { Constructor } from "@decaf-ts/decoration";
-import { InjectOptions } from "./decorators";
-declare module "@decaf-ts/decoration" {
-    namespace Metadata {
-        function injectables<T extends string | symbol | Constructor>(category?: T): (T extends undefined ? Constructor[] : Constructor) | undefined;
-        function injected<T, K extends keyof T>(model: T | Constructor<T>, prop?: K): (K extends keyof T ? InjectOptions : Record<K, InjectOptions>) | undefined;
-    }
-}

package/lib/types/constants.d.ts

@@ -1,29 +0,0 @@
-import { InjectableConfig } from "./decorators";
-/**
- * @description Constants used for reflection metadata keys in the dependency injection system.
- * @summary Injectables Reflection keys used to store and retrieve metadata about injectable classes and properties.
- * @property {string} REFLECT Reflection injectables base key prefix for all metadata keys
- * @property {string} INJECTABLE Reflection key suffix for marking a class as injectable
- * @property {string} INJECT Reflection key suffix for marking a property for injection
- * @const InjectablesKeys
- * @memberOf module:injectable-decorators
- */
-export declare const InjectablesKeys: {
-    REFLECT: string;
-    INJECTABLE: string;
-    INJECT: string;
-};
-/**
- * @description Default configuration applied by the @injectable decorator when none is provided.
- * @summary Sets sensible defaults such as singleton lifecycle for newly registered injectables.
- * @const DefaultInjectablesConfig
- * @memberOf module:injectable-decorators
- */
-export declare const DefaultInjectablesConfig: InjectableConfig;
-/**
- * @description Reflection metadata key for accessing TypeScript type information.
- * @summary Holds the key for retrieving the design type from TypeScript's reflection metadata.
- * @const TypeKey
- * @memberOf module:injectable-decorators
- */
-export declare const TypeKey = "design:type";

package/lib/types/decorators.d.ts

@@ -1,157 +0,0 @@
-import { InstanceCallback } from "./types";
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Configuration options for the @injectable decorator.
- * @summary Controls lifecycle (singleton vs on-demand) and an optional instance transformation callback executed post-construction.
- * @template T The instance type affected by the callback when provided.
- * @property {boolean} singleton When true, a single instance is shared (singleton). When false, instances are created on demand.
- * @property {InstanceCallback<T>} [callback] Optional hook to transform the instance after it is constructed.
- * @typedef InjectableConfig
- * @memberOf module:injectable-decorators
- */
-export type InjectableConfig = {
-    singleton: boolean;
-    callback?: InstanceCallback<any>;
-};
-export declare function injectableBaseDecorator(category?: string | Constructor | Partial<InjectableConfig>, cfg?: Partial<InjectableConfig>): (original: any) => any;
-/**
- * @description Decorator that marks a class as available for dependency injection.
- * @summary Defines a class as an injectable that can be retrieved from the registry.
- * When applied to a class, replaces its constructor with one that returns an instance.
- *
- * @return {function(any): any} A decorator function that transforms the class into an injectable.
- *
- * @function injectable
- */
-export declare function injectable(): (original: any) => any;
-/**
- * @description Decorator that marks a class as available for dependency injection.
- * @summary Defines a class as an injectable that can be retrieved from the registry.
- * When applied to a class, replaces its constructor with one that returns an instance.
- *
- * @param {string | Constructor} category Defaults to the class category. Useful when minification occurs and names are changed,
- * or when you want to upcast the object to a different type.
- *
- * @return {function(any): any} A decorator function that transforms the class into an injectable.
- *
- * @function injectable
- */
-export declare function injectable(category: string | Constructor): (original: any) => any;
-/**
- * @description Decorator that marks a class as available for dependency injection.
- * @summary Defines a class as an injectable that can be retrieved from the registry.
- * When applied to a class, replaces its constructor with one that returns an instance.
- *
- * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.
- *
- * @return {function(any): any} A decorator function that transforms the class into an injectable.
- *
- * @function injectable
- */
-export declare function injectable(cfg: Partial<InjectableConfig>): (original: any) => any;
-/**
- * @description Decorator that marks a class as available for dependency injection.
- * @summary Defines a class as an injectable that can be retrieved from the registry.
- * When applied to a class, replaces its constructor with one that returns an instance.
- *
- * @param category Defaults to the class category. Useful when minification occurs and names are changed,
- * or when you want to upcast the object to a different type.
- * @param {Partial<InjectableConfig>} cfg=DefaultInjectableConfig Allows overriding the default singleton behavior and adding a callback function.
- *
- * @return {function(any): any} A decorator function that transforms the class into an injectable.
- *
- * @function injectable
- */
-export declare function injectable(category: string | Constructor, cfg: Partial<InjectableConfig>): (original: any) => any;
-/**
- * @description Convenience decorator to register an injectable as a singleton.
- * @summary Wraps {@link injectable} forcing the singleton lifecycle so only one instance is created and reused.
- * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
- * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
- * @return {function(any): any} A class decorator that registers the target as a singleton injectable.
- * @function singleton
- * @category Class Decorators
- */
-export declare function singleton(category?: string | Constructor, cfg?: Omit<InjectableConfig, "singleton">): (original: any) => any;
-/**
- * @description Convenience decorator to register an injectable as on-demand (non-singleton).
- * @summary Wraps {@link injectable} forcing new instances to be created on every injection or retrieval.
- * @param {string|Constructor} [category] Optional explicit category/symbol source; defaults to the class.
- * @param {Omit<InjectableConfig, "singleton">} [cfg] Additional injectable configuration excluding the singleton flag.
- * @return {function(any): any} A class decorator that registers the target as a non-singleton injectable.
- * @function onDemand
- * @category Class Decorators
- */
-export declare function onDemand(category?: string | Constructor, cfg?: Omit<InjectableConfig, "singleton">): (original: any) => any;
-/**
- * @description Function type for transforming injectable instances before they're injected.
- * @summary Function which transforms a cached {@link injectable} instance before it's injected into a target object.
- *
- * @param {any} injectable The injectable instance to transform
- * @param {any} obj The object the injectable will be injected on
- * @return {any} The transformed injectable instance
- *
- * @typedef {Function} InstanceTransformer
- * @category Decorators
- * @memberOf module:injectable-decorators
- */
-export type InstanceTransformer = (injectable: any, obj: any) => any;
-/**
- * @description Options for the property-level @inject decorator.
- * @summary Allows specifying constructor arguments and an optional transformer to be applied to the resolved instance.
- * @property {any[]} [args] Optional constructor arguments to use when building the injectable instance.
- * @property {InstanceTransformer} [transformer] Optional function to transform the instance before assignment.
- * @typedef InjectOptions
- * @memberOf module:injectable-decorators
- */
-export type InjectOptions = {
-    args?: any[];
-    transformer?: InstanceTransformer;
-};
-export declare function injectBaseDecorator(category?: symbol | string | Constructor | Partial<InjectOptions>, cfg?: Partial<InjectOptions>): (target: any, propertyKey?: any) => void;
-/**
- * @description Property decorator that injects a dependency into a class property.
- * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
- * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
- *
- * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
- *
- * @function inject
- */
-export declare function inject(): (target: any, propertyKey: any) => void;
-/**
- * @description Property decorator that injects a dependency into a class property.
- * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
- * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
- *
- * @param {string} category Defaults to the class name derived from the property type. Useful when minification occurs
- * and names are changed, or when you want to upcast the object to a different type.
- * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
- *
- * @function inject
- */
-export declare function inject(category: string | Constructor): (target: any, propertyKey: any) => void;
-/**
- * @description Property decorator that injects a dependency into a class property.
- * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
- * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
- *
- * @param {Partial<InjectOptions>} [cfg={}] Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand
- * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
- *
- * @function inject
- */
-export declare function inject(cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;
-/**
- * @description Property decorator that injects a dependency into a class property.
- * @summary Allows for the injection of an {@link injectable} decorated dependency into a class property.
- * The property must be typed for the requested dependency. Only concrete classes are supported; generics are not.
- *
- * @param {string} category Defaults to the class name derived from the property type. Useful when minification occurs
- * and names are changed, or when you want to upcast the object to a different type.
- * @param {Partial<InjectOptions>} cfg={} Optional function to transform the injectable instance before it's injected, or arguments to pass the constructor when injecting onDemand
- * @return {function(any, any): void} A property decorator function that sets up the dependency injection.
- *
- * @function inject
- */
-export declare function inject(category: string | Constructor, cfg: Partial<InjectOptions>): (target: any, propertyKey: any) => void;

package/lib/types/index.d.ts

@@ -1,22 +0,0 @@
-/**
- * @description A lightweight dependency injection library for TypeScript applications.
- * @summary Adds a simple Injectables implementation to create singleton instances of an object
- * and easily inject it into other objects. Provides decorators for marking classes as injectable
- * and for injecting dependencies into class properties.
- *
- * @module injectable-decorators
- */
-export * from "./constants";
-export * from "./decorators";
-export * from "./Injectables";
-export * from "./registry";
-export * from "./types";
-export * from "./utils";
-/**
- * @description Current version of the injectable-decorators library.
- * @summary Defined on library build. Holds the library's current version string.
- * @const VERSION
- * @memberOf module:injectable-decorators
- */
-export declare const VERSION = "1.15.0";
-export declare const PACKAGE_NAME = "@decaf-ts/injectable-decorators";

package/lib/types/overrides.d.ts

@@ -1 +0,0 @@
-export {};

package/lib/types/registry.d.ts

@@ -1,115 +0,0 @@
-import { InjectableOptions } from "./types";
-/**
- * @description Type representing either a class constructor or an instance.
- * @summary Defines an Injectable type that can be either a class constructor or an instance of a class.
- * @template T The type of the injectable object
- * @typedef {function(any): T | T} Injectable
- * @memberOf module:injectable-decorators
- */
-export type Injectable<T> = {
-    new (...args: any[]): T;
-} | T;
-/**
- * @description Contract for a registry that manages injectable objects.
- * @summary Interface for an injectable registry that provides methods for retrieving, registering, and building injectable objects.
- * @template T Type parameter used in the interface methods
- * @interface InjectablesRegistry
- * @memberOf module:injectable-decorators
- */
-export interface InjectablesRegistry {
-    /**
-     * @description Fetches an injectable instance by its registered name.
-     * @summary Retrieves an {@link Injectable} from the registry by name, optionally passing constructor arguments.
-     * @template T Type of the injectable object to retrieve
-     * @param {symbol} name The registered name of the injectable to retrieve
-     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
-     * @return {Injectable<T> | undefined} The injectable instance or undefined if not found
-     * @memberOf module:injectable-decorators
-     */
-    get<T>(name: symbol | string | {
-        new (...args: any[]): T;
-    }, ...args: any[]): T | undefined;
-    /**
-     * @description Adds a class or object to the injectable registry.
-     * @summary Registers an injectable constructor or instance with the registry, making it available for injection.
-     * @template T Type of the injectable object to register
-     * @param {Injectable<T>} constructor The class constructor or object instance to register
-     * @param options
-     * @param {any[]} args Additional arguments for registration (category, singleton flag, etc.)
-     * @return {void}
-     * @memberOf module:injectable-decorators
-     */
-    register<T>(constructor: Injectable<T>, category: symbol | undefined, options: InjectableOptions<T>, ...args: any[]): void;
-    /**
-     * @description Creates a new instance of an injectable class.
-     * @summary Instantiates an injectable class using its constructor and the provided arguments.
-     * @template T Type of the object to build
-     * @param {symbol} name Object containing the name of the injectable to build
-     * @param {any[]} args Constructor arguments to pass when instantiating the injectable
-     * @return {T} The newly created instance
-     * @memberOf module:injectable-decorators
-     */
-    build<T>(name: symbol, ...args: any[]): T;
-}
-/**
- * @description Default implementation of the InjectablesRegistry interface.
- * @summary Holds the various {@link Injectable}s in a cache and provides methods to register, retrieve, and build them.
- * @template T Type parameter used in the class methods
- *
- * @class InjectableRegistryImp
- * @implements InjectablesRegistry
- *
- * @memberOf module:injectable-decorators
- *
- * @example
- * // Create a new registry
- * const registry = new InjectableRegistryImp();
- *
- * // Register a class
- * class MyService {
- *   doSomething() {
- *     return 'Hello World';
- *   }
- * }
- * registry.register(MyService, 'MyService', true);
- *
- * // Get the instance
- * const service = registry.get('MyService');
- * service.doSomething(); // 'Hello World'
- *
- * @mermaid
- * sequenceDiagram
- *   participant Client
- *   participant Registry
- *
- *   Client->>Registry: register(MyService)
- *   Registry->>Registry: Store in cache
- *
- *   Client->>Registry: get("MyService")
- *   alt Instance exists and is singleton
- *     Registry-->>Client: Return cached instance
- *   else No instance or not singleton
- *     Registry->>Registry: build(name)
- *     Registry-->>Client: Return new instance
- *   end
- */
-export declare class InjectableRegistryImp implements InjectablesRegistry {
-    private cache;
-    has<T>(name: symbol | {
-        new (...args: any[]): T;
-    }): boolean;
-    /**
-     * @inheritDoc
-     */
-    get<T>(name: symbol | string | {
-        new (...args: any[]): T;
-    }, ...args: any[]): T | undefined;
-    /**
-     * @inheritDoc
-     */
-    register<T>(obj: Injectable<T>, category: symbol | undefined, options: InjectableOptions<T>, force?: boolean): void;
-    /**
-     * @inheritDoc
-     */
-    build<T>(name: symbol, ...args: any[]): T;
-}

package/lib/types/types.d.ts

@@ -1,53 +0,0 @@
-import { Constructor } from "@decaf-ts/decoration";
-/**
- * @description Callback function type used to transform or initialize an instance after construction.
- * @summary Represents a post-construction hook that can modify or replace the created instance before it is returned to the caller.
- * @template T The instance type being produced and possibly transformed.
- * @param {T} instance The newly constructed instance.
- * @param {...any} args Additional arguments forwarded from the construction context.
- * @return {T} The instance to be stored/returned, which may be the original or a transformed instance.
- * @typedef InstanceCallback
- * @memberOf module:injectable-decorators
- */
-export type InstanceCallback<T> = (instance: T, ...args: any[]) => T;
-/**
- * @description Options controlling how an injectable should be handled by the registry.
- * @summary Specifies lifecycle and callback configuration for injectables, such as whether they are singletons and whether a post-build callback should run.
- * @template T The instance type governed by these options.
- * @property {boolean} singleton Indicates if the injectable should be treated as a singleton (single shared instance).
- * @property {InstanceCallback<T>} callback Optional callback invoked after building an instance to perform additional setup or transformation.
- * @typedef InjectableOptions
- * @memberOf module:injectable-decorators
- */
-export type InjectableOptions<T> = {
-    singleton: boolean;
-    callback: InstanceCallback<T>;
-};
-/**
- * @description Internal registry definition for a stored injectable entry.
- * @summary Describes how the registry caches injectable metadata, constructor, and (optionally) a built instance.
- * @template T The resolved instance type.
- * @template OPTS The options shape used for this injectable, extending {@link InjectableOptions}.
- * @property {OPTS} options The lifecycle/options associated with this injectable entry.
- * @property {*} [instance] The cached instance when applicable (e.g., singleton), otherwise undefined until built.
- * @property {Constructor} constructor The constructor used to create new instances.
- * @typedef InjectableDef
- * @memberOf module:injectable-decorators
- */
-export type InjectableDef<T = any, OPTS extends InjectableOptions<T> = InjectableOptions<T>> = {
-    options: OPTS;
-    instance?: any;
-    constructor: Constructor<T>;
-};
-/**
- * @description Metadata attached to classes marked as injectable.
- * @summary Captures identifying information stored via reflection for later retrieval and wiring.
- * @property {string} class The class name of the injectable.
- * @property {symbol} symbol The unique symbol under which the injectable is registered.
- * @typedef InjectableMetadata
- * @memberOf module:injectable-decorators
- */
-export type InjectableMetadata = {
-    class: string;
-    symbol: symbol;
-};

package/lib/types/utils.d.ts

@@ -1,9 +0,0 @@
-/**
- * @description Generates a fully qualified reflection metadata key.
- * @summary Returns the reflection key for injectables by prefixing the provided key with the base reflection key.
- * @param {string} key The key to be prefixed
- * @return {string} The fully qualified reflection key
- * @function getInjectKey
- * @memberOf module:injectable-decorators
- */
-export declare const getInjectKey: (key: string) => string;