@abdokouta/ts-container 1.0.0

package/dist/index.d.ts

@@ -0,0 +1,1576 @@
+/**
+ * @fileoverview Type interface — represents a class constructor.
+ *
+ * This is the fundamental type used throughout the DI system to represent
+ * classes that can be instantiated with `new`.
+ *
+ * @module interfaces/type
+ */
+/**
+ * Represents a class constructor (a "newable" type).
+ *
+ * Used as the type for:
+ * - Provider metatypes (the class to instantiate)
+ * - Injection tokens (when using class-based tokens)
+ * - Module classes
+ *
+ * @typeParam T - The instance type that the constructor creates
+ *
+ * @example
+ * ```typescript
+ * // Any class satisfies Type<T>
+ * class UserService {}
+ * const type: Type<UserService> = UserService;
+ *
+ * // Can be used to create instances
+ * const instance = new type();
+ * ```
+ */
+interface Type<T = any> extends Function {
+    new (...args: any[]): T;
+}
+
+/**
+ * @fileoverview Injection token type — the key used to identify providers.
+ *
+ * An injection token is the identifier that the container uses to look up
+ * a provider binding. It can be a class reference, a string, or a symbol.
+ *
+ * @module interfaces/injection-token
+ */
+
+/**
+ * A token that uniquely identifies a provider in the DI container.
+ *
+ * Three forms are supported:
+ *
+ * 1. **Class reference** — the most common form. The class itself is the token.
+ *    ```typescript
+ *    @Injectable()
+ *    class UserService {}
+ *    // Token is: UserService (the class constructor)
+ *    ```
+ *
+ * 2. **String** — useful for configuration values or when you don't have a class.
+ *    ```typescript
+ *    { provide: 'DATABASE_URL', useValue: 'postgres://...' }
+ *    ```
+ *
+ * 3. **Symbol** — the recommended approach for non-class tokens. Prevents collisions.
+ *    ```typescript
+ *    const CACHE_CONFIG = Symbol('CACHE_CONFIG');
+ *    { provide: CACHE_CONFIG, useValue: { default: 'memory' } }
+ *    ```
+ *
+ * 4. **Function** — for factory-based tokens or abstract classes.
+ */
+type InjectionToken<T = any> = string | symbol | Type<T> | Function;
+
+/**
+ * @fileoverview Provider scope enum.
+ *
+ * Defines the lifecycle scope of a provider instance.
+ * For client-side applications, DEFAULT (singleton) is the most common.
+ *
+ * @module interfaces/scope
+ */
+/**
+ * Determines how provider instances are shared.
+ *
+ * - `DEFAULT` — Singleton. One instance shared across the entire application.
+ *   This is the default and most common scope for client-side apps.
+ *
+ * - `TRANSIENT` — A new instance is created every time the provider is injected.
+ *   Useful for stateful services that shouldn't be shared.
+ *
+ * @example
+ * ```typescript
+ * // Singleton (default) — one instance for the whole app
+ * @Injectable()
+ * class ConfigService {}
+ *
+ * // Transient — new instance per injection
+ * @Injectable({ scope: Scope.TRANSIENT })
+ * class RequestLogger {}
+ * ```
+ */
+declare enum Scope {
+    /**
+     * Singleton scope. The provider is instantiated once and shared
+     * across all consumers. This is the default.
+     */
+    DEFAULT = 0,
+    /**
+     * Transient scope. A new instance is created for every injection point.
+     * Each consumer gets its own dedicated instance.
+     */
+    TRANSIENT = 1
+}
+
+/**
+ * @fileoverview Provider types — the different ways to register a dependency.
+ *
+ * Providers are the fundamental building blocks of the DI system.
+ * They tell the container HOW to create an instance for a given token.
+ *
+ * Four provider types are supported (same as NestJS):
+ *
+ * 1. **Class provider** — `{ provide: Token, useClass: SomeClass }`
+ * 2. **Value provider** — `{ provide: Token, useValue: someValue }`
+ * 3. **Factory provider** — `{ provide: Token, useFactory: () => value, inject: [Dep1] }`
+ * 4. **Existing provider** (alias) — `{ provide: Token, useExisting: OtherToken }`
+ *
+ * Plus the shorthand: just passing a class directly (equivalent to `{ provide: Class, useClass: Class }`).
+ *
+ * @module interfaces/provider
+ */
+
+/**
+ * Class provider — binds a token to a class that will be instantiated by the container.
+ *
+ * The container will:
+ * 1. Read the class's constructor parameter types
+ * 2. Resolve each dependency recursively
+ * 3. Call `new useClass(...resolvedDeps)`
+ *
+ * @example
+ * ```typescript
+ * // Bind an interface token to a concrete implementation
+ * { provide: 'IUserRepository', useClass: PostgresUserRepository }
+ *
+ * // Bind a class to itself (same as just listing the class)
+ * { provide: UserService, useClass: UserService }
+ * ```
+ */
+interface ClassProvider<T = any> {
+    /**
+   * The injection token (what consumers ask for).
+   */
+    provide: InjectionToken;
+    /**
+   * The class to instantiate when this token is requested.
+   */
+    useClass: Type<T>;
+    /**
+   * Optional scope override.
+   */
+    scope?: Scope;
+}
+/**
+ * Value provider — binds a token to a pre-existing value.
+ *
+ * No instantiation occurs. The exact value is returned as-is.
+ * Useful for configuration objects, constants, and pre-built instances.
+ *
+ * @example
+ * ```typescript
+ * // Bind a configuration object
+ * { provide: CACHE_CONFIG, useValue: { default: 'memory', stores: { ... } } }
+ *
+ * // Bind a primitive
+ * { provide: 'API_URL', useValue: 'https://api.example.com' }
+ *
+ * // Bind a pre-built instance
+ * { provide: Logger, useValue: new Logger('app') }
+ * ```
+ */
+interface ValueProvider<T = any> {
+    /**
+   * The injection token.
+   */
+    provide: InjectionToken;
+    /**
+   * The value to inject. Returned as-is, no instantiation.
+   */
+    useValue: T;
+}
+/**
+ * Factory provider — binds a token to a factory function.
+ *
+ * The factory function is called once (for singletons) or per-injection
+ * (for transients). Dependencies can be injected into the factory via
+ * the `inject` array.
+ *
+ * @example
+ * ```typescript
+ * // Simple factory
+ * {
+ *   provide: 'CONNECTION',
+ *   useFactory: () => createConnection({ host: 'localhost' }),
+ * }
+ *
+ * // Factory with injected dependencies
+ * {
+ *   provide: CacheManager,
+ *   useFactory: (config: ConfigService) => new CacheManager(config.get('cache')),
+ *   inject: [ConfigService],
+ * }
+ *
+ * // Async factory
+ * {
+ *   provide: 'DB_CONNECTION',
+ *   useFactory: async (config: ConfigService) => {
+ *     const conn = await createConnection(config.get('database'));
+ *     return conn;
+ *   },
+ *   inject: [ConfigService],
+ * }
+ * ```
+ */
+interface FactoryProvider<T = any> {
+    /**
+   * The injection token.
+   */
+    provide: InjectionToken;
+    /**
+   * Factory function that creates the value. Can be async.
+   */
+    useFactory: (...args: any[]) => T | Promise<T>;
+    /**
+   * Tokens to inject as arguments to the factory function.
+   */
+    inject?: InjectionToken[];
+    /**
+   * Optional scope override.
+   */
+    scope?: Scope;
+}
+/**
+ * Existing provider (alias) — binds a token to another token.
+ *
+ * When the alias token is requested, the container resolves the
+ * target token instead. Useful for providing multiple tokens that
+ * resolve to the same instance.
+ *
+ * @example
+ * ```typescript
+ * // Make CACHE_SERVICE resolve to the same instance as CacheManager
+ * { provide: CACHE_SERVICE, useExisting: CacheManager }
+ * ```
+ */
+interface ExistingProvider<T = any> {
+    /**
+   * The alias injection token.
+   */
+    provide: InjectionToken;
+    /**
+   * The target token to resolve instead.
+   */
+    useExisting: InjectionToken<T>;
+}
+/**
+ * Union type of all provider forms.
+ *
+ * A provider can be:
+ * - A class reference (shorthand for `{ provide: Class, useClass: Class }`)
+ * - A ClassProvider
+ * - A ValueProvider
+ * - A FactoryProvider
+ * - An ExistingProvider
+ *
+ * @example
+ * ```typescript
+ * const providers: Provider[] = [
+ *   UserService,                                          // class shorthand
+ *   { provide: 'API_URL', useValue: 'https://...' },     // value
+ *   { provide: CacheManager, useClass: CacheManager },   // class
+ *   { provide: DB, useFactory: () => connect() },        // factory
+ *   { provide: CACHE, useExisting: CacheManager },       // alias
+ * ];
+ * ```
+ */
+type Provider<T = any> = Type<T> | ClassProvider<T> | ValueProvider<T> | FactoryProvider<T> | ExistingProvider<T>;
+
+/**
+ * @fileoverview Dynamic module interface — for configurable modules.
+ *
+ * Dynamic modules are the mechanism for creating configurable, reusable modules.
+ * They're returned by static methods like `forRoot()` and `forFeature()`.
+ *
+ * @module interfaces/dynamic-module
+ */
+
+/**
+ * A module configuration object returned by `forRoot()`, `forFeature()`, etc.
+ *
+ * Extends `ModuleMetadata` with a `module` property that references the
+ * module class, and an optional `global` flag.
+ *
+ * ## How it works:
+ *
+ * When the scanner encounters a `DynamicModule` in an imports array, it:
+ * 1. Uses the `module` property to identify the module class
+ * 2. Merges the dynamic metadata (providers, imports, exports) with
+ *    any static metadata from the `@Module()` decorator
+ * 3. Registers everything into the container
+ *
+ * @example
+ * ```typescript
+ * @Module({})
+ * class CacheModule {
+ *   static forRoot(config: CacheConfig): DynamicModule {
+ *     return {
+ *       module: CacheModule,
+ *       global: true,
+ *       providers: [
+ *         { provide: CACHE_CONFIG, useValue: config },
+ *         CacheManager,
+ *       ],
+ *       exports: [CacheManager],
+ *     };
+ *   }
+ * }
+ *
+ * // Usage:
+ * @Module({
+ *   imports: [CacheModule.forRoot({ default: 'memory' })],
+ * })
+ * class AppModule {}
+ * ```
+ */
+interface DynamicModule extends ModuleMetadata {
+    /**
+     * The module class this dynamic configuration belongs to.
+     * This is how the scanner identifies which module to configure.
+     */
+    module: Type<any>;
+    /**
+     * When `true`, this module's exported providers are available globally
+     * to all other modules without explicit imports.
+     *
+     * @default false
+     */
+    global?: boolean;
+}
+
+/**
+ * @fileoverview Forward reference — for resolving circular dependencies.
+ *
+ * @module interfaces/forward-reference
+ */
+/**
+ * A forward reference wraps a class reference in a function to break
+ * circular dependency chains in the module graph.
+ *
+ * @example
+ * ```typescript
+ * import { forwardRef } from '@abdokouta/ts-container';
+ *
+ * @Module({
+ *   imports: [forwardRef(() => CatsModule)],
+ * })
+ * class DogsModule {}
+ * ```
+ */
+interface ForwardReference<T = any> {
+    forwardRef: () => T;
+}
+
+/**
+ * @fileoverview Module metadata interface — the shape of @Module() options.
+ *
+ * @module interfaces/module-metadata
+ */
+
+/**
+ * Configuration object passed to the `@Module()` decorator.
+ *
+ * Defines the module's dependency graph: what it imports, provides, and exports.
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   imports: [ConfigModule, RedisModule.forRoot(config)],
+ *   providers: [
+ *     UserService,
+ *     { provide: CACHE_CONFIG, useValue: cacheConfig },
+ *   ],
+ *   exports: [UserService],
+ * })
+ * class UserModule {}
+ * ```
+ */
+interface ModuleMetadata {
+    /**
+     * Modules to import.
+     *
+     * Imported modules make their exported providers available to this module.
+     * Can be static module classes, dynamic modules (from `forRoot()`), or forward references.
+     */
+    imports?: Array<Type<any> | DynamicModule | Promise<DynamicModule> | ForwardReference>;
+    /**
+     * Providers to register in this module.
+     *
+     * These providers are available for injection within this module.
+     * To make them available to other modules, add them to `exports`.
+     */
+    providers?: Provider[];
+    /**
+     * Providers or modules to export.
+     *
+     * Exported providers become available to modules that import this module.
+     * You can export:
+     * - Provider tokens (class, string, symbol)
+     * - Entire modules (re-exporting their exports)
+     */
+    exports?: Array<InjectionToken | Provider | DynamicModule | ForwardReference>;
+}
+
+/**
+ * @fileoverview Lifecycle hook interfaces.
+ *
+ * Providers can implement these interfaces to hook into the application
+ * lifecycle. The container calls these methods at specific points during
+ * bootstrap and shutdown.
+ *
+ * ## Lifecycle order:
+ *
+ * **Bootstrap:**
+ * 1. All providers are instantiated (constructor injection)
+ * 2. `onModuleInit()` is called on all providers that implement it
+ *
+ * **Shutdown:**
+ * 1. `onModuleDestroy()` is called on all providers that implement it
+ * 2. Provider references are released
+ *
+ * @module interfaces/lifecycle
+ */
+/**
+ * Interface for providers that need initialization after construction.
+ *
+ * `onModuleInit()` is called after all providers in the module have been
+ * instantiated and their dependencies injected. This is the right place
+ * for async initialization like connecting to databases or warming caches.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class DatabaseService implements OnModuleInit {
+ *   private connection: Connection;
+ *
+ *   constructor(@Inject(DB_CONFIG) private config: DbConfig) {}
+ *
+ *   async onModuleInit() {
+ *     // All dependencies are available here
+ *     this.connection = await createConnection(this.config);
+ *   }
+ * }
+ * ```
+ */
+interface OnModuleInit {
+    onModuleInit(): any | Promise<any>;
+}
+/**
+ * Interface for providers that need cleanup before shutdown.
+ *
+ * `onModuleDestroy()` is called when the application is shutting down.
+ * Use this to close connections, flush buffers, and release resources.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class RedisManager implements OnModuleDestroy {
+ *   async onModuleDestroy() {
+ *     await this.disconnectAll();
+ *   }
+ * }
+ * ```
+ */
+interface OnModuleDestroy {
+    onModuleDestroy(): any | Promise<any>;
+}
+
+/**
+ * @fileoverview ContainerResolver — minimal interface for resolving providers.
+ *
+ * This is the contract that any DI resolver must implement. It's used by:
+ * - `@abdokouta/ts-container/react` (ContainerProvider accepts this)
+ * - `@pixielity/application` (ApplicationContext implements this)
+ * - Any custom resolver or testing mock
+ *
+ * By depending on this interface instead of a concrete class, consumers
+ * stay decoupled from the bootstrap implementation.
+ *
+ * @module interfaces/container-resolver
+ */
+
+/**
+ * Minimal interface for resolving providers from a DI container.
+ *
+ * Any object that can look up providers by token can implement this.
+ * The React hooks (`useInject`, etc.) depend on this interface,
+ * not on the concrete `ApplicationContext`.
+ *
+ * @example
+ * ```typescript
+ * // ApplicationContext implements this
+ * const app: ContainerResolver = await ApplicationContext.create(AppModule);
+ * const service = app.get(UserService);
+ *
+ * // You can also create a mock for testing
+ * const mock: ContainerResolver = {
+ *   get: (token) => mockInstances.get(token),
+ *   getOptional: (token) => mockInstances.get(token),
+ *   has: (token) => mockInstances.has(token),
+ * };
+ * ```
+ */
+interface ContainerResolver {
+    /**
+     * Resolve a provider by its injection token.
+     *
+     * @param token - The injection token (class, string, or symbol)
+     * @returns The resolved provider instance
+     * @throws Error if the provider is not found
+     */
+    get<T = any>(token: InjectionToken<T>): T;
+    /**
+     * Try to resolve a provider, returning `undefined` if not found.
+     *
+     * @param token - The injection token
+     * @returns The resolved instance or undefined
+     */
+    getOptional<T = any>(token: InjectionToken<T>): T | undefined;
+    /**
+     * Check if a provider is registered.
+     *
+     * @param token - The injection token to check
+     * @returns `true` if the provider exists
+     */
+    has(token: InjectionToken): boolean;
+}
+
+/**
+ * @fileoverview Scope options for the @Injectable() decorator.
+ * @module interfaces/scope-options
+ */
+
+/**
+ * Options that can be passed to `@Injectable()` to control provider scoping.
+ *
+ * @example
+ * ```typescript
+ * @Injectable({ scope: Scope.TRANSIENT })
+ * class TransientService {}
+ * ```
+ */
+interface ScopeOptions {
+    /**
+     * The scope of the provider.
+     * @default Scope.DEFAULT (singleton)
+     */
+    scope?: Scope;
+}
+
+/**
+ * @fileoverview @Injectable() decorator.
+ *
+ * Marks a class as a provider that can be managed by the DI container.
+ * This is the most fundamental decorator in the system — any class that
+ * needs to be injected or have dependencies injected into it must be
+ * decorated with `@Injectable()`.
+ *
+ * ## What it does:
+ *
+ * 1. Sets the `__injectable__` watermark on the class (so the scanner can identify it)
+ * 2. Stores scope options (singleton vs transient) as metadata
+ * 3. TypeScript's `emitDecoratorMetadata` automatically emits `design:paramtypes`
+ *    (constructor parameter types) because a decorator is present on the class
+ *
+ * That third point is crucial — without `@Injectable()`, TypeScript won't emit
+ * the constructor parameter type metadata that the injector needs to auto-resolve
+ * dependencies.
+ *
+ * @module decorators/injectable
+ */
+
+/**
+ * Decorator that marks a class as injectable (a provider).
+ *
+ * @param options - Optional scope configuration
+ *
+ * @example
+ * ```typescript
+ * // Basic usage — singleton by default
+ * @Injectable()
+ * class UserService {
+ *   constructor(private config: ConfigService) {}
+ * }
+ *
+ * // Transient scope — new instance per injection
+ * @Injectable({ scope: Scope.TRANSIENT })
+ * class RequestLogger {
+ *   private readonly id = Math.random();
+ * }
+ * ```
+ */
+declare function Injectable(options?: ScopeOptions): ClassDecorator;
+
+/**
+ * @fileoverview @Inject() decorator.
+ *
+ * Explicitly specifies the injection token for a constructor parameter
+ * or class property. This is needed when:
+ *
+ * 1. The token is a string or symbol (not a class)
+ * 2. You want to inject a different implementation than the parameter type
+ * 3. The parameter type is an interface (interfaces are erased at runtime)
+ *
+ * ## How it works:
+ *
+ * **Constructor parameter injection:**
+ * Pushes `{ index, param: token }` into the `self:paramtypes` metadata array.
+ * During resolution, the injector merges `self:paramtypes` with `design:paramtypes`
+ * — explicit `@Inject()` tokens override the auto-detected types.
+ *
+ * **Property injection:**
+ * Pushes `{ key, type: token }` into the `self:properties_metadata` array.
+ * After construction, the injector resolves each property dependency and
+ * assigns it to the instance.
+ *
+ * @module decorators/inject
+ */
+
+/**
+ * Decorator that specifies the injection token for a dependency.
+ *
+ * Can be used on constructor parameters or class properties.
+ *
+ * @param token - The injection token to use. If omitted, falls back to
+ *                the TypeScript-emitted type or the property's design:type.
+ *
+ * @example
+ * ```typescript
+ * // Constructor parameter injection with a symbol token
+ * @Injectable()
+ * class CacheService {
+ *   constructor(
+ *     @Inject(CACHE_CONFIG) private config: CacheModuleOptions,
+ *     @Inject(RedisManager) private redis: RedisManager,
+ *   ) {}
+ * }
+ *
+ * // Property injection
+ * @Injectable()
+ * class UserService {
+ *   @Inject(LoggerService)
+ *   private logger!: LoggerService;
+ * }
+ *
+ * // Without explicit token — uses the TypeScript type
+ * @Injectable()
+ * class OrderService {
+ *   constructor(private userService: UserService) {}
+ *   // Equivalent to: @Inject(UserService) private userService: UserService
+ * }
+ * ```
+ */
+declare function Inject(token?: InjectionToken | ForwardReference): PropertyDecorator & ParameterDecorator;
+
+/**
+ * @fileoverview @Optional() decorator.
+ *
+ * Marks a dependency as optional. If the container cannot resolve the
+ * dependency, `undefined` is injected instead of throwing an error.
+ *
+ * @module decorators/optional
+ */
+
+/**
+ * Marks a constructor parameter or property dependency as optional.
+ *
+ * Without `@Optional()`, an unresolvable dependency throws an error.
+ * With `@Optional()`, `undefined` is injected instead.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class CacheService {
+ *   constructor(
+ *     @Inject(CACHE_CONFIG) private config: CacheConfig,
+ *     @Optional() @Inject(RedisManager) private redis?: RedisManager,
+ *   ) {
+ *     // redis will be undefined if RedisModule is not imported
+ *   }
+ * }
+ * ```
+ */
+declare function Optional(): PropertyDecorator & ParameterDecorator;
+
+/**
+ * @fileoverview @Module() decorator.
+ *
+ * Defines a module — the organizational unit of the DI system.
+ * Modules group related providers and define the dependency graph
+ * between different parts of the application.
+ *
+ * ## How it works:
+ *
+ * The decorator iterates over the metadata object and stores each
+ * property as a separate metadata entry on the class:
+ *
+ * ```
+ * @Module({ imports: [...], providers: [...], exports: [...] })
+ * class MyModule {}
+ *
+ * // Becomes:
+ * Reflect.defineMetadata('imports', [...], MyModule)
+ * Reflect.defineMetadata('providers', [...], MyModule)
+ * Reflect.defineMetadata('exports', [...], MyModule)
+ * ```
+ *
+ * The scanner later reads these metadata entries to build the module graph.
+ *
+ * @module decorators/module
+ */
+
+/**
+ * Decorator that defines a module.
+ *
+ * @param metadata - Module configuration (imports, providers, exports)
+ *
+ * @example
+ * ```typescript
+ * @Module({
+ *   imports: [ConfigModule.forRoot(config)],
+ *   providers: [UserService, UserRepository],
+ *   exports: [UserService],
+ * })
+ * class UserModule {}
+ * ```
+ */
+declare function Module$1(metadata: ModuleMetadata): ClassDecorator;
+
+/**
+ * @fileoverview @Global() decorator.
+ *
+ * Makes a module's exported providers available globally to all other
+ * modules without requiring explicit imports.
+ *
+ * @module decorators/global
+ */
+
+/**
+ * Decorator that makes a module global-scoped.
+ *
+ * Once a global module is imported anywhere (typically in the root module),
+ * its exported providers become available to ALL modules in the application
+ * without needing to import the module explicitly.
+ *
+ * Use sparingly — global modules reduce explicitness. Good candidates:
+ * - Configuration modules
+ * - Logger modules
+ * - Database connection modules
+ *
+ * @example
+ * ```typescript
+ * @Global()
+ * @Module({
+ *   providers: [ConfigService],
+ *   exports: [ConfigService],
+ * })
+ * class ConfigModule {
+ *   static forRoot(config: AppConfig): DynamicModule {
+ *     return {
+ *       module: ConfigModule,
+ *       global: true, // Can also be set here instead of @Global()
+ *       providers: [{ provide: APP_CONFIG, useValue: config }, ConfigService],
+ *       exports: [ConfigService],
+ *     };
+ *   }
+ * }
+ * ```
+ */
+declare function Global(): ClassDecorator;
+
+/**
+ * @fileoverview forwardRef utility — resolves circular module dependencies.
+ *
+ * @module utils/forward-ref
+ */
+
+/**
+ * Creates a forward reference to break circular dependency chains.
+ *
+ * When two modules import each other, TypeScript may resolve one of them
+ * as `undefined` due to the ES module evaluation order. `forwardRef()`
+ * wraps the reference in a function that's called later, after both
+ * modules have been fully defined.
+ *
+ * @param fn - A function that returns the class reference
+ * @returns A ForwardReference object
+ *
+ * @example
+ * ```typescript
+ * // cats.module.ts
+ * @Module({
+ *   imports: [forwardRef(() => DogsModule)],
+ * })
+ * class CatsModule {}
+ *
+ * // dogs.module.ts
+ * @Module({
+ *   imports: [forwardRef(() => CatsModule)],
+ * })
+ * class DogsModule {}
+ * ```
+ */
+declare function forwardRef<T = any>(fn: () => T): ForwardReference<T>;
+
+/**
+ * @fileoverview InstanceWrapper — wraps a provider binding with its metadata and instance.
+ *
+ * Every provider registered in a module gets wrapped in an InstanceWrapper.
+ * The wrapper tracks:
+ * - The injection token (how consumers ask for it)
+ * - The metatype (the class/factory to instantiate)
+ * - The resolved instance (once created)
+ * - The scope (singleton vs transient)
+ * - Whether it's been resolved yet
+ * - Factory dependencies (for useFactory providers)
+ *
+ * This is a simplified version of NestJS's InstanceWrapper — we don't need
+ * request scoping, context IDs, or transient maps for client-side use.
+ *
+ * @module injector/instance-wrapper
+ */
+
+/**
+ * Wraps a single provider binding with all its metadata.
+ *
+ * @typeParam T - The type of the provider instance
+ */
+declare class InstanceWrapper<T = any> {
+    /**
+   * The injection token used to look up this provider.
+   */
+    readonly token: InjectionToken;
+    /**
+   * Human-readable name (class name or token string).
+   */
+    readonly name: string;
+    /**
+     * The class constructor or factory function.
+     * - For class providers: the class to `new`
+     * - For factory providers: the factory function
+     * - For value providers: `null`
+     */
+    metatype: Type<T> | Function | null;
+    /**
+     * The resolved instance.
+     * - `null` before resolution
+     * - The actual instance after resolution
+     * - For value providers: set immediately at registration
+     */
+    instance: T | null;
+    /**
+   * Whether this provider has been fully resolved (instance created).
+   */
+    isResolved: boolean;
+    /**
+   * The scope of this provider.
+   */
+    scope: Scope;
+    /**
+     * For factory providers: the tokens to inject as factory arguments.
+     * `null` for class and value providers.
+     */
+    inject: InjectionToken[] | null;
+    /**
+     * Whether this is an alias (useExisting) provider.
+     * Alias providers delegate resolution to another token.
+     */
+    isAlias: boolean;
+    /**
+   * Whether the instance is a Promise (async factory).
+   */
+    async: boolean;
+    /**
+   * The module this provider belongs to.
+   */
+    host: Module | null;
+    /**
+     * Create a new InstanceWrapper.
+     *
+     * @param metadata - Initial values for the wrapper properties
+     */
+    constructor(metadata?: Partial<InstanceWrapper<T>>);
+    /**
+     * Whether this provider is a factory (has an `inject` array).
+     * Factory providers are invoked as functions, not constructed with `new`.
+     */
+    get isFactory(): boolean;
+    /**
+     * Whether this provider is transient (new instance per injection).
+     */
+    get isTransient(): boolean;
+    /**
+     * Extract a human-readable name from a token.
+     */
+    private getTokenName;
+}
+
+/**
+ * @fileoverview Module — the runtime representation of a @Module() class.
+ *
+ * Each `@Module()` decorated class gets a corresponding `Module` instance
+ * at runtime. The Module holds:
+ * - All provider bindings (as InstanceWrappers)
+ * - References to imported modules
+ * - The set of exported tokens
+ *
+ * ## Module lifecycle:
+ *
+ * 1. **Registration** — The scanner creates a Module instance and registers
+ *    providers, imports, and exports based on the @Module() metadata.
+ *
+ * 2. **Resolution** — The injector resolves all providers in the module,
+ *    creating instances and injecting dependencies.
+ *
+ * 3. **Lifecycle hooks** — After all providers are resolved, onModuleInit()
+ *    is called on providers that implement it.
+ *
+ * @module injector/module
+ */
+
+/**
+ * Runtime representation of a module.
+ *
+ * Created by the scanner for each `@Module()` class encountered during
+ * the module graph traversal.
+ */
+declare class Module {
+    /**
+   * Unique identifier for this module instance.
+   */
+    readonly id: string;
+    /**
+   * The original class decorated with @Module().
+   */
+    readonly metatype: Type<any>;
+    /**
+   * Whether this module is global (its exports are available everywhere).
+   */
+    isGlobal: boolean;
+    /**
+   * The opaque token used to identify this module in the container.
+   */
+    token: string;
+    /**
+     * All providers registered in this module.
+     * Key: injection token, Value: InstanceWrapper
+     */
+    private readonly _providers;
+    /**
+   * Imported modules (their exports are available to this module).
+   */
+    private readonly _imports;
+    /**
+   * Tokens that this module exports (available to modules that import this one).
+   */
+    private readonly _exports;
+    constructor(metatype: Type<any>);
+    get name(): string;
+    get providers(): Map<InjectionToken, InstanceWrapper>;
+    get imports(): Set<Module>;
+    get exports(): Set<InjectionToken>;
+    /**
+     * Register a provider in this module.
+     *
+     * Handles all provider forms:
+     * - Class shorthand: `UserService`
+     * - Class provider: `{ provide: Token, useClass: UserService }`
+     * - Value provider: `{ provide: Token, useValue: someValue }`
+     * - Factory provider: `{ provide: Token, useFactory: fn, inject: [...] }`
+     * - Existing provider: `{ provide: Token, useExisting: OtherToken }`
+     *
+     * @param provider - The provider to register
+     * @returns The injection token for this provider
+     */
+    addProvider(provider: Provider): InjectionToken;
+    /**
+     * Register a custom provider (one with a `provide` property).
+     */
+    private addCustomProvider;
+    /**
+     * Register a class provider: `{ provide: Token, useClass: SomeClass }`
+     */
+    private addClassProvider;
+    /**
+     * Register a value provider: `{ provide: Token, useValue: value }`
+     *
+     * Value providers are immediately resolved — the value is stored as-is.
+     */
+    private addValueProvider;
+    /**
+     * Register a factory provider: `{ provide: Token, useFactory: fn, inject: [...] }`
+     *
+     * The factory function is stored as the metatype and will be called
+     * (not constructed with `new`) during resolution.
+     */
+    private addFactoryProvider;
+    /**
+     * Register an existing (alias) provider: `{ provide: Token, useExisting: OtherToken }`
+     *
+     * Implemented as a factory that resolves the target token.
+     */
+    private addExistingProvider;
+    /**
+   * Add an imported module.
+   */
+    addImport(moduleRef: Module): void;
+    /**
+     * Add an exported token.
+     *
+     * @param token - The token to export (class, string, symbol, or module class)
+     */
+    addExport(token: InjectionToken): void;
+    /**
+     * Check if this module has a provider for the given token.
+     */
+    hasProvider(token: InjectionToken): boolean;
+    /**
+     * Get a provider wrapper by token.
+     */
+    getProviderByToken<T = any>(token: InjectionToken): InstanceWrapper<T> | undefined;
+    /**
+     * Read the scope from a class's @Injectable() metadata.
+     */
+    private getClassScope;
+    /**
+     * Get a human-readable name from a token.
+     */
+    private getTokenName;
+}
+
+/**
+ * @fileoverview NestContainer — the top-level container that holds all modules.
+ *
+ * This is the central registry of the DI system. It holds:
+ * - All registered modules (keyed by opaque token)
+ * - The set of global modules
+ * - Dynamic module metadata
+ *
+ * ## How the container is used:
+ *
+ * 1. The **scanner** calls `addModule()` for each module in the graph
+ * 2. The **scanner** calls `addProvider()`, `addImport()`, `addExport()` to populate modules
+ * 3. The **scanner** calls `bindGlobalScope()` to link global modules to all other modules
+ * 4. The **injector** reads from modules to resolve dependencies
+ *
+ * The container itself does NOT resolve dependencies — that's the injector's job.
+ * The container is purely a data structure that holds the module graph.
+ *
+ * @module injector/container
+ */
+
+/**
+ * The type of a module definition — can be a class, dynamic module, or promise.
+ */
+type ModuleMetatype = Type<any> | DynamicModule | Promise<DynamicModule>;
+/**
+ * The top-level DI container.
+ *
+ * Holds all modules and their provider bindings. Created once during
+ * application bootstrap and shared throughout the application lifetime.
+ */
+declare class NestContainer {
+    /**
+     * All registered modules, keyed by their opaque token.
+     * The token is derived from the module class name (or a hash for dynamic modules).
+     */
+    private readonly modules;
+    /**
+     * Global modules whose exports are available to all other modules.
+     */
+    private readonly globalModules;
+    /**
+     * Dynamic module metadata, keyed by module token.
+     * Stored separately because dynamic metadata is merged with static @Module() metadata.
+     */
+    private readonly dynamicModulesMetadata;
+    /**
+     * Add a module to the container.
+     *
+     * If the module is already registered (by token), returns the existing one.
+     * Otherwise, creates a new Module instance and registers it.
+     *
+     * @param metatype - The module class or dynamic module
+     * @returns The Module instance and whether it was newly inserted
+     */
+    addModule(metatype: ModuleMetatype): Promise<{
+        moduleRef: Module;
+        inserted: boolean;
+    }>;
+    /**
+     * Add a provider to a module.
+     *
+     * @param provider - The provider to add
+     * @param token - The module token to add the provider to
+     */
+    addProvider(provider: Provider, token: string): void;
+    /**
+     * Add an import relationship between modules.
+     *
+     * @param relatedModule - The module being imported
+     * @param token - The token of the module doing the importing
+     */
+    addImport(relatedModule: Type<any> | DynamicModule, token: string): void;
+    /**
+     * Add an export to a module.
+     *
+     * @param toExport - The token or provider to export
+     * @param token - The module token
+     */
+    addExport(toExport: InjectionToken | Provider | DynamicModule, token: string): void;
+    /**
+     * Link all global modules to all non-global modules as imports.
+     *
+     * Called after all modules have been scanned. This makes global modules'
+     * exports available everywhere without explicit imports.
+     */
+    bindGlobalScope(): void;
+    /**
+   * Get all registered modules.
+   */
+    getModules(): Map<string, Module>;
+    /**
+   * Get a module by its token.
+   */
+    getModuleByToken(token: string): Module | undefined;
+    /**
+     * Get dynamic metadata for a module.
+     *
+     * @param token - The module token
+     * @param key - Optional specific key to retrieve (e.g., 'imports', 'providers')
+     */
+    getDynamicMetadata(token: string): Partial<DynamicModule> | undefined;
+    getDynamicMetadata<K extends keyof DynamicModule>(token: string, key: K): DynamicModule[K] | undefined;
+    /**
+   * Clear all modules (for testing).
+   */
+    clear(): void;
+    /**
+     * Extract the module class, dynamic metadata, and token from a module definition.
+     *
+     * Handles both static modules (just a class) and dynamic modules
+     * (objects with a `module` property).
+     */
+    private extractModuleMetadata;
+    /**
+     * Check if a module definition is a dynamic module (has a `module` property).
+     */
+    private isDynamicModule;
+    /**
+     * Check if a module should be global.
+     * A module is global if:
+     * - It has the @Global() decorator, OR
+     * - Its dynamic metadata has `global: true`
+     */
+    private isGlobalModule;
+}
+
+/**
+ * @fileoverview Injector — resolves dependencies and creates provider instances.
+ *
+ * The injector is the engine that turns the module graph (built by the scanner)
+ * into actual, live instances. For each provider, it:
+ *
+ * 1. Reads constructor parameter types from metadata
+ * 2. Resolves each dependency (recursively)
+ * 3. Creates the instance (via `new` for classes, or by calling the factory)
+ * 4. Applies property injection
+ * 5. Marks the provider as resolved
+ *
+ * ## Resolution algorithm:
+ *
+ * For a given token in a given module:
+ * 1. Look in the module's own providers
+ * 2. If not found, look in imported modules' exports (recursively)
+ * 3. If still not found, throw UnknownDependencyError
+ *
+ * ## Singleton vs Transient:
+ *
+ * - Singleton (DEFAULT): resolved once, cached in the InstanceWrapper
+ * - Transient: a new instance is created every time it's injected
+ *
+ * @module injector/injector
+ */
+
+/**
+ * The Injector resolves and instantiates providers.
+ *
+ * It's stateless — all state lives in the InstanceWrappers within modules.
+ * The injector just reads metadata and creates instances.
+ */
+declare class Injector {
+    /**
+     * Tracks which wrappers are currently being resolved, to detect circular dependencies.
+     * Uses a Set of tokens being resolved in the current chain.
+     */
+    private readonly resolutionStack;
+    /**
+     * Resolve all providers in a module.
+     *
+     * Iterates over all providers and resolves each one.
+     * Value providers are already resolved at registration time.
+     *
+     * @param moduleRef - The module whose providers to resolve
+     */
+    resolveProviders(moduleRef: Module): Promise<void>;
+    /**
+     * Resolve a single provider instance.
+     *
+     * This is the core resolution method. It handles:
+     * - Already-resolved singletons (returns cached instance)
+     * - Circular dependency detection
+     * - Factory providers (calls the factory function)
+     * - Class providers (resolves constructor deps, then `new`)
+     * - Property injection (after construction)
+     * - Async factories (awaits the result)
+     *
+     * @param wrapper - The InstanceWrapper to resolve
+     * @param moduleRef - The module context for dependency lookup
+     */
+    resolveInstance<T>(wrapper: InstanceWrapper<T>, moduleRef: Module): Promise<T>;
+    /**
+     * Look up a provider by token, searching the module and its imports.
+     *
+     * Resolution order:
+     * 1. The module's own providers
+     * 2. Imported modules' exported providers (breadth-first)
+     *
+     * @param token - The injection token to look up
+     * @param moduleRef - The module context
+     * @returns The InstanceWrapper and the module it was found in
+     */
+    lookupProvider(token: InjectionToken, moduleRef: Module): {
+        wrapper: InstanceWrapper;
+        host: Module;
+    } | undefined;
+    /**
+     * Resolve a class provider by:
+     * 1. Reading constructor parameter types from metadata
+     * 2. Resolving each dependency
+     * 3. Calling `new Class(...deps)`
+     * 4. Applying property injection
+     */
+    private resolveClass;
+    /**
+     * Resolve a factory provider by:
+     * 1. Resolving the factory's `inject` dependencies
+     * 2. Calling the factory function with the resolved deps
+     * 3. Awaiting the result if it's a Promise
+     */
+    private resolveFactory;
+    /**
+     * Resolve a single dependency token to its instance.
+     *
+     * Looks up the provider, resolves it if needed, and returns the instance.
+     */
+    private resolveDependency;
+    /**
+     * Look up a provider in imported modules' exports.
+     *
+     * Searches breadth-first through the import tree, only considering
+     * providers that are in the imported module's exports set.
+     */
+    private lookupInImports;
+    /**
+     * Get the constructor dependencies for a class.
+     *
+     * Merges TypeScript's auto-emitted `design:paramtypes` with
+     * explicitly declared `self:paramtypes` (from @Inject decorators).
+     * Explicit declarations override auto-detected types.
+     *
+     * @param type - The class to read metadata from
+     * @returns Array of injection tokens, one per constructor parameter
+     */
+    private getConstructorDependencies;
+    /**
+     * Get the indices of optional constructor parameters.
+     */
+    private getOptionalDependencies;
+    /**
+     * Resolve property-injected dependencies and assign them to the instance.
+     */
+    private resolveProperties;
+    /**
+     * Format the resolution stack for error messages.
+     */
+    private formatResolutionStack;
+    /**
+     * Get a human-readable name from a token.
+     */
+    private getTokenName;
+}
+
+/**
+ * @fileoverview InstanceLoader — orchestrates provider instantiation and lifecycle hooks.
+ *
+ * After the scanner has built the module graph, the InstanceLoader:
+ * 1. Resolves all providers in all modules (via the Injector)
+ * 2. Calls `onModuleInit()` on providers that implement it
+ *
+ * It also provides `destroy()` for calling `onModuleDestroy()` during shutdown.
+ *
+ * @module injector/instance-loader
+ */
+
+/**
+ * Loads (instantiates) all providers and runs lifecycle hooks.
+ */
+declare class InstanceLoader {
+    private readonly container;
+    private readonly injector;
+    constructor(container: NestContainer);
+    /**
+     * Instantiate all providers in all modules.
+     *
+     * Iterates modules and resolves each module's providers.
+     * After all providers are resolved, calls `onModuleInit()` lifecycle hooks.
+     */
+    createInstances(): Promise<void>;
+    /**
+     * Call `onModuleDestroy()` on all providers that implement it.
+     *
+     * Called during application shutdown. Iterates modules in reverse
+     * order (leaf modules first, root module last).
+     */
+    destroy(): Promise<void>;
+    /**
+     * Get the injector instance (for direct resolution outside the module system).
+     */
+    getInjector(): Injector;
+    /**
+     * Call `onModuleInit()` on all resolved providers in a module.
+     */
+    private callModuleInitHooks;
+    /**
+     * Call `onModuleDestroy()` on all resolved providers in a module.
+     */
+    private callModuleDestroyHooks;
+}
+
+/**
+ * @fileoverview DependenciesScanner — recursively scans the module tree.
+ *
+ * The scanner is the first phase of the DI bootstrap. It walks the module
+ * graph starting from the root module and:
+ *
+ * 1. Registers each module in the container
+ * 2. Registers each module's providers
+ * 3. Sets up import relationships between modules
+ * 4. Sets up export declarations
+ * 5. Links global modules to all other modules
+ *
+ * After scanning, the container has a complete picture of the module graph
+ * but NO instances have been created yet. That's the injector's job.
+ *
+ * ## Scan algorithm:
+ *
+ * ```
+ * scan(RootModule)
+ *   → scanForModules(RootModule)        // recursive DFS
+ *     → addModule(RootModule)
+ *     → scanForModules(ImportedModule1)  // recurse into imports
+ *     → scanForModules(ImportedModule2)
+ *   → scanModulesForDependencies()      // second pass
+ *     → for each module:
+ *       → reflectImports()
+ *       → reflectProviders()
+ *       → reflectExports()
+ *   → bindGlobalScope()                 // link globals
+ * ```
+ *
+ * @module injector/scanner
+ */
+
+/**
+ * Scans the module tree and populates the container.
+ */
+declare class DependenciesScanner {
+    private readonly container;
+    constructor(container: NestContainer);
+    /**
+     * Scan the entire module tree starting from the root module.
+     *
+     * This is the main entry point. After this method completes,
+     * the container has all modules, providers, imports, and exports
+     * registered — but no instances created.
+     *
+     * @param rootModule - The root module class (your AppModule)
+     */
+    scan(rootModule: Type<any>): Promise<void>;
+    /**
+     * Recursively discover and register all modules in the graph.
+     *
+     * Uses DFS traversal. Tracks visited modules to avoid infinite loops
+     * from circular imports.
+     *
+     * @param moduleDefinition - The module to scan (class or dynamic module)
+     * @param ctxRegistry - Already-visited modules (for cycle detection)
+     */
+    private scanForModules;
+    /**
+     * For each registered module, read its metadata and register
+     * providers, imports, and exports.
+     */
+    private scanModulesForDependencies;
+    /**
+     * Read and register a module's imports.
+     *
+     * Merges static @Module({ imports }) with dynamic module imports.
+     */
+    private reflectImports;
+    /**
+     * Read and register a module's providers.
+     *
+     * Merges static @Module({ providers }) with dynamic module providers.
+     */
+    private reflectProviders;
+    /**
+     * Read and register a module's exports.
+     *
+     * Merges static @Module({ exports }) with dynamic module exports.
+     */
+    private reflectExports;
+    /**
+     * Get a module's imports from both static and dynamic sources.
+     */
+    private getModuleImports;
+    /**
+     * Resolve a forward reference to its actual value.
+     */
+    private resolveForwardRef;
+    /**
+     * Check if a module definition is a dynamic module.
+     */
+    private isDynamicModule;
+    /**
+     * Get a human-readable name for a module.
+     */
+    private getModuleName;
+}
+
+/**
+ * @fileoverview Metadata keys and constants used throughout the DI system.
+ *
+ * These constants define the metadata keys that decorators write to classes
+ * and that the injector reads during resolution. They mirror NestJS's
+ * internal constants but are simplified for client-side use.
+ *
+ * ## How metadata flows:
+ *
+ * 1. **Decorators** write metadata using `Reflect.defineMetadata(KEY, value, target)`
+ * 2. **Scanner** reads module metadata (`imports`, `providers`, `exports`) to build the module graph
+ * 3. **Injector** reads constructor metadata (`design:paramtypes`, `self:paramtypes`) to resolve dependencies
+ *
+ * @module constants
+ */
+/**
+ * Keys used by the `@Module()` decorator to store module configuration.
+ *
+ * The `@Module()` decorator iterates over the metadata object and calls
+ * `Reflect.defineMetadata(key, value, target)` for each property.
+ *
+ * @example
+ * ```typescript
+ * // When you write:
+ * @Module({ imports: [ConfigModule], providers: [UserService], exports: [UserService] })
+ * class AppModule {}
+ *
+ * // The decorator stores:
+ * Reflect.defineMetadata('imports', [ConfigModule], AppModule)
+ * Reflect.defineMetadata('providers', [UserService], AppModule)
+ * Reflect.defineMetadata('exports', [UserService], AppModule)
+ * ```
+ */
+declare const MODULE_METADATA: {
+    readonly IMPORTS: "imports";
+    readonly PROVIDERS: "providers";
+    readonly EXPORTS: "exports";
+};
+/**
+ * Metadata key set by `@Global()` decorator.
+ * When present and `true`, the module's exported providers are available
+ * to all other modules without explicit imports.
+ */
+declare const GLOBAL_MODULE_METADATA = "__module:global__";
+/**
+ * Watermark set by `@Injectable()` to mark a class as a provider.
+ * The scanner uses this to validate that providers are properly decorated.
+ */
+declare const INJECTABLE_WATERMARK = "__injectable__";
+/**
+ * Scope options metadata set by `@Injectable({ scope: Scope.REQUEST })`.
+ * For client-side use, we primarily support DEFAULT (singleton) and TRANSIENT.
+ */
+declare const SCOPE_OPTIONS_METADATA = "scope:options";
+/**
+ * TypeScript's built-in metadata key for constructor parameter types.
+ * Automatically emitted when `emitDecoratorMetadata: true` in tsconfig.
+ *
+ * Contains an array of constructor parameter types (class references).
+ * This is the primary source for auto-resolving dependencies.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   constructor(private config: ConfigService, private logger: LoggerService) {}
+ * }
+ * // TypeScript emits: Reflect.defineMetadata('design:paramtypes', [ConfigService, LoggerService], UserService)
+ * ```
+ */
+declare const PARAMTYPES_METADATA = "design:paramtypes";
+/**
+ * Metadata key for explicitly declared constructor dependencies.
+ * Written by `@Inject(token)` decorator for constructor parameters.
+ *
+ * Contains an array of `{ index: number, param: InjectionToken }` objects.
+ * These override the auto-detected types from `design:paramtypes`.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class CacheService {
+ *   constructor(@Inject(CACHE_CONFIG) private config: CacheConfig) {}
+ * }
+ * // @Inject writes: [{ index: 0, param: CACHE_CONFIG }] to 'self:paramtypes'
+ * ```
+ */
+declare const SELF_DECLARED_DEPS_METADATA = "self:paramtypes";
+/**
+ * Metadata key for optional constructor dependencies.
+ * Written by `@Optional()` decorator for constructor parameters.
+ *
+ * Contains an array of parameter indices that are optional.
+ * If resolution fails for an optional dependency, `undefined` is injected instead of throwing.
+ */
+declare const OPTIONAL_DEPS_METADATA = "optional:paramtypes";
+/**
+ * Metadata key for property-based injection targets.
+ * Written by `@Inject(token)` when used on a class property.
+ *
+ * Contains an array of `{ key: string, type: InjectionToken }` objects.
+ *
+ * @example
+ * ```typescript
+ * @Injectable()
+ * class UserService {
+ *   @Inject(LoggerService)
+ *   private logger!: LoggerService;
+ * }
+ * ```
+ */
+declare const PROPERTY_DEPS_METADATA = "self:properties_metadata";
+/**
+ * Metadata key for optional property dependencies.
+ * Written by `@Optional()` when used on a class property.
+ *
+ * Contains an array of property keys that are optional.
+ */
+declare const OPTIONAL_PROPERTY_DEPS_METADATA = "optional:properties_metadata";
+
+export { type ClassProvider, type ContainerResolver, DependenciesScanner, type DynamicModule, type ExistingProvider, type FactoryProvider, type ForwardReference, GLOBAL_MODULE_METADATA, Global, INJECTABLE_WATERMARK, Inject, Injectable, type InjectionToken, Injector, InstanceLoader, InstanceWrapper, MODULE_METADATA, Module$1 as Module, type ModuleMetadata, Module as ModuleRef, NestContainer, OPTIONAL_DEPS_METADATA, OPTIONAL_PROPERTY_DEPS_METADATA, type OnModuleDestroy, type OnModuleInit, Optional, PARAMTYPES_METADATA, PROPERTY_DEPS_METADATA, type Provider, SCOPE_OPTIONS_METADATA, SELF_DECLARED_DEPS_METADATA, Scope, type ScopeOptions, type Type, type ValueProvider, forwardRef };