ts-ioc-container/typings/container/Container.d.ts

Fast, lightweight TypeScript dependency injection container with a clean API, scoped lifecycles, decorators, tokens, hooks, lazy injection, customizable providers, and no global container objects.

import { type CreateScopeOptions, type DependencyKey, type IContainer, type IContainerModule, type RegisterOptions, ResolveManyOptions, type ResolveOneOptions, type Tag } from './IContainer';
import { type IInjector } from '../injector/IInjector';
import { type IProvider } from '../provider/IProvider';
import { type IRegistration } from '../registration/IRegistration';
import { OnConstructHook } from '../hooks/onConstruct';
import { OnDisposeHook } from '../hooks/onDispose';
import { constructor, Instance } from '../utils/basic';
export declare class Container implements IContainer {
    isDisposed: boolean;
    private parent;
    private scopes;
    private instances;
    private registrations;
    private readonly tags;
    private readonly providers;
    private readonly aliases;
    private readonly injector;
    private readonly onConstructHookList;
    private readonly onDisposeHookList;
    constructor(options?: {
        injector?: IInjector;
        parent?: IContainer;
        tags?: Tag[];
    });
    register(key: DependencyKey, provider: IProvider, { aliases }?: RegisterOptions): this;
    resolve<T>(target: constructor<T> | DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
    resolveByAlias<T>(alias: DependencyKey, { args, child, lazy, excludedKeys }?: ResolveManyOptions): T[];
    resolveOneByAlias<T>(alias: DependencyKey, { args, child, lazy }?: ResolveOneOptions): T;
    createScope({ tags }?: CreateScopeOptions): IContainer;
    dispose(): void;
    addRegistration(registration: IRegistration): this;
    getRegistrations(): IRegistration[];
    hasRegistration(key: DependencyKey): boolean;
    addOnConstructHook(...hooks: OnConstructHook[]): this;
    addOnDisposeHook(...hooks: OnDisposeHook[]): this;
    addInstance(instance: Instance): void;
    getScopes(): IContainer[];
    hasInstance(instance: object): boolean;
    getScopeByInstanceOrFail(instance: object): IContainer;
    removeScope(child: IContainer): void;
    useModule(module: IContainerModule): this;
    getParent(): IContainer;
    getInstances(cascade?: boolean): Instance<unknown>[];
    hasTag(tag: Tag): boolean;
    addTags(...tags: Tag[]): void;
    private validateContainer;
    private findProviderByKeyOrFail;
}