diject 0.0.1

package/dist/index.d.ts

@@ -0,0 +1,823 @@
+import { AsyncLocalStorage } from 'async_hooks';
+
+declare class AlsToken<T = any> {
+    readonly key: string;
+    constructor(key: string);
+    static isAlsToken(token: any): token is AlsToken;
+}
+declare function createAlsToken<T = any>(key: string): AlsToken<T>;
+declare const INJECTIONS: unique symbol;
+
+declare enum Scope {
+    SINGLETON = "singleton",
+    REQUEST = "request",
+    TRANSIENT = "transient"
+}
+declare class FactoryWrapper {
+    factory: Function;
+    pending?: Promise<any>;
+    constructor(factory: Function);
+}
+declare function hasOnInit(instance: any): instance is OnInit;
+declare function hasOnDestroy(instance: any): instance is OnDestroy;
+declare function isNamedToken(token: unknown): token is Token;
+declare function isConstructor(token: unknown): token is Constructor;
+declare function isArrayToken(token: unknown): token is Constructor[];
+declare function isRegistryEntry(value: unknown): value is RegistryEntry;
+declare function hasSingletonInstance(entry: RegistryEntry): boolean;
+declare function isReqScope(entry: RegistryEntry, requestId?: string): boolean;
+declare function hasSingletonPending(entry: RegistryEntry): boolean;
+declare function hasOnBootComplete(instance: any): instance is {
+    onBootComplete: () => Promise<void>;
+};
+declare function isAlsToken(token: unknown): token is AlsToken;
+
+type Constructor<T = any> = new (...args: any[]) => T;
+type Factory<T = any> = (requestId?: string) => T;
+type AsyncFactory<T = any> = (requestId?: string) => Promise<T>;
+interface OnInit {
+    onInit(): void | Promise<void>;
+}
+interface OnDestroy {
+    onDestroy(): void | Promise<void>;
+}
+interface OnBootComplete {
+    onBootComplete(): void | Promise<void>;
+}
+type Metadata = Record<string, any>;
+interface MetadataQuery {
+    [key: string]: any | ((value: any) => boolean);
+}
+interface RegistryEntry {
+    scope: Scope;
+    factory: (requestId?: string) => any;
+    pending?: Promise<any>;
+    instance?: any;
+    metadata?: Metadata;
+}
+type Token = Constructor | string | symbol | AlsToken;
+type Options = {
+    scope?: Scope;
+    deps?: Constructor[];
+    factory?: Factory | AsyncFactory;
+    metadata?: Metadata;
+};
+interface PropertyInjection {
+    propertyKey: string | symbol;
+    token: any;
+    optional?: boolean;
+}
+interface PropsInject {
+    name?: string;
+    global?: boolean;
+    canInject?(instance: any, constructor: Constructor): boolean;
+    inject(instance: any, constructor?: Constructor, registry?: Map<any, any>, injections?: PropertyInjection[]): void | Promise<void>;
+}
+interface RegEntryOpts {
+    token: Token | Constructor;
+    type?: string;
+    scope?: Scope;
+    factory?: Factory;
+    deps?: Constructor[];
+    input?: unknown;
+    metadata?: Metadata;
+}
+type TStore = Record<string, any>;
+interface InjectionDefinition {
+    type: string;
+    target?: Constructor;
+    methodName?: string;
+    propertyKey?: string | symbol;
+    handler?: Function;
+    options?: any;
+    order?: number;
+    scope?: 'global' | 'controller' | 'method';
+    name?: string;
+    [key: string]: any;
+}
+
+declare class Resolver {
+    private container;
+    private resolving;
+    private instances;
+    private nameToToken;
+    private registry;
+    private requestScoped;
+    private requestPromises;
+    private store;
+    constructor(container: Container);
+    getInjections<T>(type: string): T[];
+    getInjectionsFor<T>(type: string, target: Constructor, methodName?: string): T[];
+    hasInjection(type: any, target: Constructor, methodName?: string): boolean;
+    private getRequestId;
+    private resolveToken;
+    get<T>(token: string): T;
+    get<T>(token: symbol): T;
+    get<T>(token: Constructor<T>, requestId?: string): T;
+    private getBindingSync;
+    resolve<T>(token: string): Promise<T>;
+    resolve<T>(token: symbol): Promise<T>;
+    resolve<T>(token: Constructor<T>, requestId?: string): Promise<T>;
+    private resolveBinding;
+    private createInstance;
+    private cache;
+    init(instance: any): Promise<void>;
+    destroy(instance: any): Promise<void>;
+    private getReqCache;
+    private getReqPromiseCache;
+    private ensureReqPromiseCache;
+    private ensureReqCache;
+    getOrdered<T>(token: any, key: keyof T, direction?: 'asc' | 'desc'): T[];
+    private isObject;
+    private checkTokenExist;
+    private checkCircularDep;
+    private getByName;
+    /**
+     * Get all registered tokens
+     */
+    findAll(): Token[];
+    /**
+     * Get all registered values (entries)
+     */
+    getAll(): any[];
+    /**
+     * Get all entries as [token, value] pairs
+     */
+    entries(): [Token, any][];
+    /**
+     * Get only class constructors (filters out symbols, configs, primitives)
+     */
+    getClasses(): Constructor[];
+    /**
+     * Check if value is a class constructor
+     */
+    private isClass;
+}
+
+declare class Instantiator {
+    private container;
+    private propsInject;
+    private injectorTokens;
+    constructor(container: Container);
+    build<T>(ClassRef: Constructor<T>, requestId?: string, explicitDeps?: Constructor[]): Promise<T>;
+    private resolveDependencies;
+    private injectProperties;
+    private isInjectorToken;
+    addInjector(injector: PropsInject): void;
+    use(injector: PropsInject): this;
+}
+
+declare class AlsStore<T extends Record<string, any> = any> {
+    protected readonly als: AsyncLocalStorage<Map<string, any>>;
+    run<R>(data: Partial<T>, fn: () => R): R;
+    get<K extends keyof T>(key: K): T[K] | undefined;
+    set<K extends keyof T>(key: K, data: T[K]): void;
+    set(data: Partial<T>): void;
+    has(key: keyof T): boolean;
+    isActive(): boolean;
+    all(): Partial<T> | undefined;
+    delete(key: keyof T): void;
+    clear(): void;
+}
+
+declare class Container {
+    private static instance;
+    readonly registry: Map<Token, RegistryEntry>;
+    readonly nameToToken: Map<string, Token>;
+    readonly requestScoped: Map<string, Map<Token, any>>;
+    readonly requestPromises: Map<string, Map<Token, Promise<any>>>;
+    readonly instantiator: Instantiator;
+    private readonly register;
+    readonly resolver: Resolver;
+    private readonly deleter;
+    readonly store: AlsStore<TStore>;
+    constructor();
+    /**
+     * Get the global singleton container instance
+     * Creates one if it doesn't exist
+     */
+    static getInstance(): Container;
+    /**
+     * Create a new isolated container instance
+     * Useful for testing to avoid shared state
+     * @example
+     * const testContainer = Container.create();
+     */
+    static create(): Container;
+    /**
+     * Reset the global singleton instance
+     * Clears all registrations and creates a fresh container
+     * Primarily for testing cleanup
+     */
+    static reset(): Promise<Container>;
+    /**
+     * Check if a global instance exists
+     */
+    static hasInstance(): boolean;
+    set<T>(token: Token, value: T): this;
+    set<T>(token: string, value: T): this;
+    set<T>(token: symbol, value: T): this;
+    set<T>(token: Constructor[], options?: Scope | Options): this;
+    set<T>(token: Constructor, value?: T | Scope | Options): this;
+    use(injector: any): this;
+    get<T>(token: AlsToken<T>): T | any;
+    get<T>(token: Constructor<T>, requestId?: string): T;
+    get<T>(token: string): T | any;
+    get<T>(token: symbol): T | any;
+    resolve<T>(token: Token | Constructor<T>, requestId?: string): Promise<T>;
+    resolve<T>(token: string): Promise<T | any>;
+    resolve<T>(token: symbol): Promise<T>;
+    push<T>(token: Token, ...items: T[]): this;
+    filter<T>(token: Token, predicate: (item: T) => boolean): T[];
+    setInjection(definition: InjectionDefinition): Token;
+    getInjections<T extends {
+        type: string;
+    }>(type: T['type']): T[];
+    getInjectionsFor<T extends {
+        type: string;
+        target?: Constructor;
+        methodName?: string;
+    }>(type: T['type'], target: Constructor, methodName?: string): T[];
+    getOrdered<T>(token: Token, key: keyof T, direction?: 'asc' | 'desc'): T[];
+    has(token: Token): boolean;
+    delete(token: Token): Promise<void>;
+    run<R>(data: Partial<TStore>, fn: () => R): R;
+    isActive(): boolean;
+    all(): Partial<TStore> | undefined;
+    clearStore(): void;
+    cleanupReq(requestId?: string): Promise<void>;
+    bulkRemove(items: Constructor[]): Promise<this>;
+    clear(): Promise<void>;
+    /**
+     * Configure default metadata values that will be applied to all future registrations
+     * @param metadata - Default metadata to merge with existing defaults
+     * @example
+     * container.setDefaults({ layer: 'core', priority: 10 })
+     * container.setDefaults({ domain: 'auth', critical: true })
+     */
+    setDefaults(metadata: Metadata): this;
+    /**
+     * Set metadata on a token
+     * @example
+     * container.setMeta(UserService, 'layer', 'domain')
+     * container.setMeta(UserService, { layer: 'domain', priority: 5 })
+     */
+    setMeta(token: Token, key: string, value: any): this;
+    setMeta(token: Token, metadata: Metadata): this;
+    /**
+     * Get metadata from a token
+     * @example
+     * container.getMeta(UserService, 'layer') // 'domain'
+     * container.getMeta(UserService) // { layer: 'domain', priority: 5 }
+     */
+    getMeta(token: Token, key?: string): any;
+    /**
+     * Check if token has metadata key
+     */
+    hasMeta(token: Token, key: string): boolean;
+    /**
+     * Delete metadata from a token
+     */
+    deleteMeta(token: Token, key: string): this;
+    /**
+     * Clear all metadata from a token
+     */
+    clearMeta(token: Token): this;
+    /**
+     * Find tokens by metadata query
+     * @example
+     * container.find({ layer: 'core' })
+     * container.find({ layer: 'domain', priority: (p) => p > 5 })
+     * container.find({ type: 'controller' })
+     * container.find({ type: 'service' })
+     */
+    find(query: MetadataQuery): Token[];
+    /**
+     * Find tokens that have a specific metadata key
+     * @example
+     * container.findByKey('priority')
+     */
+    findByKey(key: string): Token[];
+    /**
+     * Group tokens by a metadata key
+     * @example
+     * container.groupBy('layer') // Map { 'core' => [...], 'domain' => [...] }
+     * container.groupBy('type')  // Map { 'controller' => [...], 'service' => [...] }
+     */
+    groupBy(key: string): Map<any, Token[]>;
+    /**
+     * Get all unique values for a metadata key
+     * @example
+     * container.getValues('layer') // Set { 'core', 'domain', 'app' }
+     * container.getValues('type')  // Set { 'controller', 'service', 'repository' }
+     */
+    getValues(key: string): Set<any>;
+    /**
+     * Filter tokens with custom predicate
+     * @example
+     * container.filterBy((meta) => meta.tags?.includes('critical'))
+     */
+    filterBy(predicate: (metadata: Metadata, token: Token) => boolean): Token[];
+    /**
+     * Bulk set metadata on multiple tokens
+     * @example
+     * container.bulkSetMeta([UserService, OrderService], { layer: 'domain' })
+     */
+    bulkSetMeta(tokens: Token[], metadata: Metadata): this;
+    boot<T = any>(services?: Token[] | Constructor[]): Promise<T[]>;
+    /**
+     * Boot services by metadata query
+     * @example
+     * await container.bootBy({ layer: 'core' })
+     * await container.bootBy({ type: 'controller' })
+     * await container.bootBy({ critical: true })
+     */
+    bootBy(query: MetadataQuery): Promise<void>;
+    /**
+     * Boot services in phases based on metadata
+     * @example
+     * await container.bootPhased('layer', ['core', 'domain', 'app'])
+     * await container.bootPhased('type', ['service', 'controller'])
+     */
+    bootPhased(key: string, phases: any[]): Promise<void>;
+    /**
+     * Boot with custom ordering by metadata key
+     * @example
+     * await container.bootOrdered('priority', 'desc')
+     */
+    bootOrdered(key: string, order?: 'asc' | 'desc'): Promise<void>;
+    private notifyBootComplete;
+    load(providers: Constructor[]): Promise<void>;
+    /**
+     * Get all registered tokens
+     * @example
+     * container.findAll() // [UserService, Symbol(config), 'myToken', ...]
+     */
+    findAll(): Token[];
+    /**
+     * Get all registered values/entries
+     * @example
+     * container.getAll() // [RegistryEntry, configValue, ...]
+     */
+    getAll(): any[];
+    /**
+     * Get all entries as [token, value] pairs
+     * @example
+     * container.entries() // [[UserService, entry], [Symbol(config), value], ...]
+     */
+    entries(): [Token, any][];
+    /**
+     * Get only class constructors (filters out symbols, configs, primitives)
+     * Useful for scanning decorators on classes
+     * @example
+     * container.getClasses() // [UserService, OrderController, AuthRepository, ...]
+     */
+    getClasses(): Constructor[];
+}
+declare const container: Container;
+declare function set<T>(token: AlsToken<T>, value: T): Container;
+declare function set<T>(token: string, value: T): Container;
+declare function set<T>(token: symbol, value: T): Container;
+declare function set<T>(token: Constructor[], options?: Scope | Options): Container;
+declare function set<T>(token: Constructor<T>, value?: T | Scope | Options): Container;
+declare function get<T>(token: AlsToken<T>): T | any;
+declare function get<T>(token: Constructor<T>, requestId?: string): T;
+declare function get<T>(token: string): T | any;
+declare function get<T>(token: symbol): T | any;
+declare function resolve<T>(token: Constructor<T>, requestId?: string): Promise<T>;
+declare function resolve<T>(token: string): Promise<T>;
+declare function resolve<T>(token: symbol): Promise<T>;
+declare function has(token: Token): boolean;
+declare function boot(services?: Constructor[]): Promise<any[]>;
+declare function reset(): Promise<Container>;
+declare function findAll(): Token[];
+declare function getAll(): any[];
+declare function getClasses(): Constructor[];
+
+declare class BaseError extends Error {
+    readonly code: string;
+    message: string;
+    readonly status?: number;
+    name: string;
+    constructor(code: string, message: string, status?: number);
+    toJSON(): Record<string, any>;
+    toResponse(): Response;
+    static is(error: unknown): error is BaseError;
+    static hasCode(error: unknown, code: string): boolean;
+    static from(error: unknown, fallbackStatus?: number): BaseError;
+}
+declare const DI_CODES: {
+    readonly MISSING_PROVIDER: "DI_001";
+    readonly CIRCULAR_DEPENDENCY: "DI_002";
+    readonly NOT_INJECTABLE: "DI_003";
+    readonly SCOPE_VIOLATION: "DI_004";
+    readonly CONSTRUCTOR_RESOLUTION: "DI_005";
+    readonly TYPE_MISMATCH: "DI_006";
+    readonly NOT_REGISTERED: "DI_007";
+    readonly SINGLETON_NOT_INITIALIZED: "DI_008";
+    readonly REQUEST_ID_REQUIRED: "DI_009";
+    readonly REQUEST_INSTANCE_NOT_FOUND: "DI_010";
+    readonly TRANSIENT_SYNC_NOT_SUPPORTED: "DI_011";
+    readonly ASYNC_FACTORY_REQUIRED: "DI_012";
+    readonly CANNOT_PUSH_TO_CLASS: "DI_013";
+};
+declare const DIError: {
+    missingProvider: (token: Token, context?: string) => never;
+    circularDependency: (chain: Token[]) => never;
+    notInjectable: (target: Constructor) => never;
+    scopeViolation: (token: Token, reason: string) => never;
+    constructorResolve: (target: Constructor, index: number) => never;
+    typeMismatch: (target: Constructor, expected: string, actual: string) => never;
+    notRegistered: (token: Token) => never;
+    singletonNotInitialized: (token: Token) => never;
+    requestIdRequired: (token: Token) => never;
+    requestInstanceNotFound: (token: Token, requestId: string) => never;
+    transientSyncNotSupported: (token: Token) => never;
+    asyncFactoryRequired: (token: Token) => never;
+    cannotPushToClass: (token: Token) => never;
+};
+
+declare class MetadataManager {
+    private registry;
+    private keyIndex;
+    private valueIndex;
+    constructor(registry: Map<Token, any>);
+    set(token: Token, key: string, value: any): void;
+    set(token: Token, metadata: Metadata): void;
+    private updateIndexes;
+    get(token: Token, key?: string): any;
+    has(token: Token, key: string): boolean;
+    delete(token: Token, key: string): void;
+    clear(token: Token): void;
+    find(query: MetadataQuery): Token[];
+    private parseQuery;
+    private findTokens;
+    private findByIntersection;
+    private findByScan;
+    private sortTokens;
+    findByKey(key: string): Token[];
+    getValues(key: string): Set<any>;
+    groupBy(key: string): Map<any, Token[]>;
+    filter(predicate: (metadata: Metadata, token: Token) => boolean): Token[];
+    private matches;
+    bulkSet(tokens: Token[], metadata: Metadata): void;
+    copy(from: Token, to: Token): void;
+    removeToken(token: Token): void;
+    clearIndexes(): void;
+}
+
+declare class Register {
+    private container;
+    private registry;
+    private nameToToken;
+    private instantiator;
+    private store;
+    readonly metadata: MetadataManager;
+    private defaultMetadata;
+    constructor(container: Container);
+    setDefaults(metadata: Metadata): this;
+    push<T>(token: Token, ...items: T[]): void;
+    filter<T>(token: Token, predicate: (item: T) => boolean): T[];
+    setInjection(definition: InjectionDefinition): Token;
+    set<T>(token: string, input: T): this;
+    set<T>(token: symbol, value: T): this;
+    set<T>(token: Constructor[], options?: Scope | Options): this;
+    set<T>(token: Constructor, input?: Scope | Options): this;
+    set<T>(token: AlsToken<T>, input: T): this;
+    private registerEntry;
+    private handleConstructor;
+    private handleArrayToken;
+    private handleNamedToken;
+    private handleAlsToken;
+    private validateType;
+    private resolveCtx;
+    /**
+     * Resolve scope with priority:
+     * 1. Explicit scope passed to set() (e.g., container.set(Svc, Scope.REQUEST))
+     * 2. Scope in options object (e.g., container.set(Svc, { scope: Scope.REQUEST }))
+     * 3. Scope from decorator (e.g., @Service(Scope.REQUEST))
+     * 4. Default: SINGLETON
+     */
+    private resolveScope;
+    private isFactory;
+    private isScope;
+    private asOptions;
+    private isInstance;
+    private cleanInput;
+    private cleanOptions;
+    getByName(name: string): Token | undefined;
+}
+
+declare class Deleter {
+    private readonly container;
+    private readonly registry;
+    private readonly store;
+    private readonly nameToToken;
+    private readonly requestScoped;
+    private readonly requestPromises;
+    constructor(container: Container);
+    cleanupReq(requestId?: string): Promise<void>;
+    private destroyRequestScopedInstances;
+    private clearRequestMaps;
+    delete(token: Token): Promise<void>;
+    private deleteAlsToken;
+    private deleteNamedToken;
+    private deleteRegistryToken;
+    private destroyRegistryValue;
+    private cleanTokenFromRequestScopes;
+    private removeTokenFromMaps;
+    clear(): Promise<void>;
+    private collectRegistryDestroyPromises;
+    private collectRequestScopedDestroyPromises;
+    private shouldSkipRegistryEntry;
+    private extractInstance;
+    private clearAllMaps;
+    private clearRegistryPreservingContainer;
+    destroy(instance: any): Promise<void>;
+    private resolveRequestId;
+    private resolveToken;
+    private isDestroyableValue;
+}
+
+/** Marks a class as injectable */
+declare const INJECTABLE: unique symbol;
+/** Scope of the injectable (singleton, transient, request) */
+declare const SCOPE: unique symbol;
+/** Type category: 'service' | 'controller' | 'repository' | etc. */
+declare const CLASS_TYPE: unique symbol;
+/** Custom metadata attached via @Meta() */
+declare const METADATA: unique symbol;
+/** @Service marker */
+declare const SERVICE: unique symbol;
+/** @Controller marker */
+declare const CONTROLLER: unique symbol;
+/** @Controller path */
+declare const CONTROLLER_PATH: unique symbol;
+/** @Repository marker */
+declare const REPOSITORY: unique symbol;
+/** @Repository database name */
+declare const DATABASE: unique symbol;
+/** Property injection metadata */
+declare const INJECT_PROPS: unique symbol;
+/** Constructor parameter injection metadata */
+declare const INJECT_PARAMS: unique symbol;
+/** @Scan property decorator metadata */
+declare const SCAN_PROPS: unique symbol;
+declare const DESIGN_PARAMTYPES = "design:paramtypes";
+declare const DESIGN_TYPE = "design:type";
+declare const DESIGN_RETURNTYPE = "design:returntype";
+
+type NextFunction = () => void;
+interface InjectableType {
+    token: Token;
+    index: number;
+}
+interface InjectableOptions {
+    scope?: Scope;
+}
+interface Registration {
+    factory: Factory;
+    scope: Scope;
+}
+type DecoratorMetadata = Record<string, any>;
+interface ServiceOptions {
+    scope?: Scope;
+    metadata?: DecoratorMetadata;
+}
+interface ControllerOptions {
+    path?: string;
+    metadata?: DecoratorMetadata;
+}
+interface RepositoryOptions {
+    database?: string;
+    metadata?: DecoratorMetadata;
+}
+
+/**
+ * Get the class type set by decorators
+ * Returns: 'service' | 'controller' | 'repository' | undefined
+ */
+declare function getClassType(target: Function): string | undefined;
+/**
+ * @internal Used by decorators to set class type
+ */
+declare function setClassType(target: Function, type: string): void;
+declare function isInjectable(target: Function): boolean;
+/**
+ * @internal
+ */
+declare function setInjectable(target: Function, value?: boolean): void;
+declare function getScope(target: Function): Scope;
+/**
+ * @internal
+ */
+declare function setScope(target: Function, scope: Scope): void;
+declare function getDecoratorMetadata(target: Function): DecoratorMetadata;
+declare function hasDecoratorMetadata(target: Function, key: string): boolean;
+declare function getDecoratorMetadataValue<T = any>(target: Function, key: string): T | undefined;
+/**
+ * @internal
+ */
+declare function mergeMetadata(target: Function, metadata: DecoratorMetadata): void;
+
+/**
+ * Get constructor or method parameter types via reflect-metadata
+ *
+ * @example
+ * ```ts
+ * // Constructor params
+ * getParamTypes(MyClass) // [UserRepo, Logger]
+ *
+ * // Method params
+ * getParamTypes(MyClass.prototype, 'someMethod') // [string, number]
+ * ```
+ */
+declare function getParamTypes(target: any, propertyKey?: string | symbol): any[];
+/**
+ * Get the declared type of a property via reflect-metadata
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   @Inject() userRepo: UserRepository;
+ * }
+ *
+ * getPropertyType(MyService.prototype, 'userRepo') // UserRepository
+ * ```
+ */
+declare function getPropertyType(target: any, propertyKey: string | symbol): any;
+/**
+ * Get the return type of a method via reflect-metadata
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   getUser(): User { ... }
+ * }
+ *
+ * getReturnType(MyService.prototype, 'getUser') // User
+ * ```
+ */
+declare function getReturnType(target: any, propertyKey: string | symbol): any;
+/**
+ * Get property or return type via reflect-metadata
+ *
+ * @deprecated Use getPropertyType() or getReturnType() instead
+ */
+declare function getReflectType(target: any, propertyKey: string | symbol, kind?: 'property' | 'return'): any;
+
+declare class MetaHelper {
+    static get<T>(key: symbol, target: any, propertyKey?: string | symbol): T | any;
+    static define(key: symbol, value: any, target: any, propertyKey?: string | symbol): void;
+    static append<T>(key: symbol, value: T, target: any, propertyKey?: string): void;
+    static appendMany<T>(key: symbol, values: T[], target: any, propertyKey?: string | symbol): void;
+    static merge<T extends Record<string, any>>(key: symbol, value: T, target: any, propertyKey?: string): void;
+}
+
+/**
+ * Core Inject decorator - injects dependencies into properties and constructor parameters
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   @Inject() userRepo: UserRepository;
+ *   @Inject('config') config: any;
+ *
+ *   constructor(@Inject('db') db: Database) {}
+ * }
+ * ```
+ */
+declare function Inject(token?: any): any;
+declare function getPropertyInjections(target: Function): any[];
+declare function getParameterInjections(target: Function): any[];
+
+/**
+ * Core Injectable decorator - marks a class as injectable
+ *
+ * @internal Use @Service, @Repository, or @Controller instead
+ *
+ * @example
+ * ```ts
+ * @Injectable()
+ * class GenericService {}
+ *
+ * @Injectable(Scope.TRANSIENT)
+ * class TransientService {}
+ * ```
+ */
+declare function Injectable(scope?: Scope): ClassDecorator;
+
+/**
+ * Service decorator - marks a class as an injectable service
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * class UserService {}
+ *
+ * @Service(Scope.TRANSIENT)
+ * class RequestHandler {}
+ *
+ * @Service({ scope: Scope.SINGLETON, metadata: { layer: 'domain' } })
+ * class DomainService {}
+ * ```
+ */
+declare function Service(options?: Scope | ServiceOptions): ClassDecorator;
+declare function isService(target: Function): boolean;
+
+/**
+ * Controller decorator with optional metadata
+ *
+ * @example
+ * ```ts
+ * @Controller('/users')
+ * class UserController {}
+ *
+ * @Controller({ path: '/api/users', metadata: { version: 'v1' } })
+ * class UserApiController {}
+ * ```
+ */
+declare function Controller(options?: string | ControllerOptions): ClassDecorator;
+declare function isController(target: Function): boolean;
+declare function getPath(target: Function): string | undefined;
+
+/**
+ * Repository decorator for data access layer
+ *
+ * @example
+ * ```ts
+ * @Repository()
+ * class UserRepository {}
+ *
+ * @Repository('postgres')
+ * class PostgresUserRepository {}
+ *
+ * @Repository({ database: 'mongodb', metadata: { layer: 'data' } })
+ * class MongoUserRepository {}
+ * ```
+ */
+declare function Repository(options?: string | RepositoryOptions): ClassDecorator;
+declare function isRepository(target: Function): boolean;
+declare function getDatabase(target: Function): string | undefined;
+
+/**
+ * Stackable metadata decorator for classes
+ *
+ * @example
+ * ```ts
+ * @Service()
+ * @Meta({ layer: 'domain', priority: 10 })
+ * @Meta({ tags: ['critical'] })
+ * class UserService {}
+ * ```
+ */
+declare function Meta(metadata: DecoratorMetadata): ClassDecorator;
+
+/**
+ * Inject the DI Container itself
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   @DI() container: Container;
+ *
+ *   doSomething() {
+ *     const config = this.container.get('config');
+ *   }
+ * }
+ * ```
+ */
+declare function DI(): PropertyDecorator;
+
+/**
+ * Inject AlsStore for accessing AsyncLocalStorage context
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   @Store() store: AlsStore;
+ *
+ *   doSomething() {
+ *     const requestId = this.store.get(REQUEST_ID);
+ *   }
+ * }
+ * ```
+ */
+declare function Store(): PropertyDecorator;
+
+/**
+ * Value injection decorator - injects values (strings, objects, numbers) by token
+ * Returns undefined if the token is not registered (optional by default)
+ *
+ * @example
+ * ```ts
+ * class MyService {
+ *   @Value('API_KEY') apiKey?: string;
+ *   @Value('CONFIG') config?: { port: number };
+ *   @Value(DATABASE_URL) dbUrl?: string;
+ * }
+ * ```
+ */
+declare function Value(token: any): PropertyDecorator;
+
+export { AlsStore, AlsToken, type AsyncFactory, BaseError, CLASS_TYPE, CONTROLLER, CONTROLLER_PATH, type Constructor, Container, Controller, type ControllerOptions, DATABASE, DESIGN_PARAMTYPES, DESIGN_RETURNTYPE, DESIGN_TYPE, DI, DIError, DI_CODES, type DecoratorMetadata, Deleter, type Factory, FactoryWrapper, INJECTABLE, INJECTIONS, INJECT_PARAMS, INJECT_PROPS, Inject, Injectable, type InjectableOptions, type InjectableType, type InjectionDefinition, Instantiator, METADATA, Meta, MetaHelper, type Metadata, MetadataManager, type MetadataQuery, type NextFunction, type OnBootComplete, type OnDestroy, type OnInit, type Options, type PropertyInjection, type PropsInject, REPOSITORY, type RegEntryOpts, Register, type Registration, type RegistryEntry, Repository, type RepositoryOptions, Resolver, SCAN_PROPS, SCOPE, SERVICE, Scope, Service, type ServiceOptions, Store, type TStore, type Token, Value, boot, container, createAlsToken, findAll, get, getAll, getClassType, getClasses, getDatabase, getDecoratorMetadata, getDecoratorMetadataValue, getParamTypes, getParameterInjections, getPath, getPropertyInjections, getPropertyType, getReflectType, getReturnType, getScope, has, hasDecoratorMetadata, hasOnBootComplete, hasOnDestroy, hasOnInit, hasSingletonInstance, hasSingletonPending, isAlsToken, isArrayToken, isConstructor, isController, isInjectable, isNamedToken, isRegistryEntry, isRepository, isReqScope, isService, mergeMetadata, reset, resolve, set, setClassType, setInjectable, setScope };