@tsclean/core/dist/core/injector/module.d.ts

Plugin for API Rest Full development, based on Clean Architecture, IoC and Dependency Injection.

import { EnhancerSubtype } from '../../helpers';
import { ContainerIoC } from './container';
import { InstanceWrapper } from './instance-wrapper';
import { ModuleRef } from './module-ref';
import { ClassProvider, DynamicModuleInterface, ExistingProvider, FactoryProvider, InjectionToken, ModuleInterface, Type, ValueProvider } from '../../contracts';
import { ControllerType, InjectableType, InstanceTokenType, ProviderType } from '../../types';
export declare class Module {
    private readonly _metaType;
    private readonly container;
    private readonly _id;
    private readonly _imports;
    private readonly _providers;
    private readonly _injectables;
    private readonly _middlewares;
    private readonly _controllers;
    private readonly _exports;
    private _distance;
    private _initOnPreview;
    private _isGlobal;
    private _token;
    constructor(_metaType: Type<any>, container: ContainerIoC);
    get id(): string;
    get token(): string;
    get name(): string;
    get isGlobal(): boolean;
    set isGlobal(global: boolean);
    get initOnPreview(): boolean;
    set initOnPreview(initOnPreview: boolean);
    set token(token: string);
    get providers(): Map<InstanceTokenType, InstanceWrapper<InjectableType>>;
    get middlewares(): Map<InstanceTokenType, InstanceWrapper<InjectableType>>;
    get imports(): Set<Module>;
    get routes(): Map<InstanceTokenType, InstanceWrapper<ControllerType>>;
    get injectables(): Map<InstanceTokenType, InstanceWrapper<InjectableType>>;
    get controllers(): Map<InstanceTokenType, InstanceWrapper<ControllerType>>;
    get exports(): Set<InstanceTokenType>;
    get instance(): ModuleInterface;
    get metaType(): Type<any>;
    get distance(): number;
    set distance(value: number);
    addCoreProviders(): void;
    addModuleRef(): void;
    addModuleAsProvider(): void;
    addApplicationConfig(): void;
    addInjectable<T extends InjectableType>(injectable: ProviderType, enhancerSubtype: EnhancerSubtype, host?: Type<T>): string | symbol | Function | Type<any> | import("../../contracts").AbstractInterface<any>;
    addProvider(provider: ProviderType): InjectionToken;
    addProvider(provider: ProviderType, enhancerSubtype: EnhancerSubtype): InjectionToken;
    isCustomProvider(provider: ProviderType): provider is ClassProvider | FactoryProvider | ValueProvider | ExistingProvider;
    addCustomProvider(provider: ClassProvider | FactoryProvider | ValueProvider | ExistingProvider, collection: Map<Function | string | symbol, any>, enhancerSubtype?: EnhancerSubtype): string | symbol | Function | Type<any> | import("../../contracts").AbstractInterface<any>;
    isCustomClass(provider: any): provider is ClassProvider;
    isCustomValue(provider: any): provider is ValueProvider;
    isCustomFactory(provider: any): provider is FactoryProvider;
    isCustomUseExisting(provider: any): provider is ExistingProvider;
    isDynamicModule(exported: any): exported is DynamicModuleInterface;
    addCustomClass(provider: ClassProvider, collection: Map<InstanceTokenType, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
    addCustomValue(provider: ValueProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
    addCustomFactory(provider: FactoryProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
    addCustomUseExisting(provider: ExistingProvider, collection: Map<Function | string | symbol, InstanceWrapper>, enhancerSubtype?: EnhancerSubtype): void;
    addExportedProvider(provider: ProviderType | string | symbol | DynamicModuleInterface): Set<InstanceTokenType>;
    addCustomExportedProvider(provider: FactoryProvider | ValueProvider | ClassProvider | ExistingProvider): Set<InstanceTokenType>;
    validateExportedProvider(token: InstanceTokenType): InstanceTokenType;
    addController(controller: Type<ControllerType>): void;
    assignControllerUniqueId(controller: Type<ControllerType>): void;
    addRelatedModule(module: Module): void;
    replace(toReplace: InstanceTokenType, options: any): void;
    hasProvider(token: InstanceTokenType): boolean;
    hasInjectable(token: InstanceTokenType): boolean;
    getProviderByKey<T = any>(name: InstanceTokenType): InstanceWrapper<T>;
    createModuleReferenceType(): Type<ModuleRef>;
}
//# sourceMappingURL=module.d.ts.map