import { Disposable } from '../disposable';
import { Logger, LoggerCollection } from '../index';
import { Constructable } from './constructable';
/**
 * Container for injectable instances
 */
export declare class Injector implements Disposable {
    /**
     * Returns the registered Logger instance
     */
    get logger(): LoggerCollection;
    /**
     * Registers a Logger service to the injector container with the provided loggers.
     */
    useLogging(...loggers: Array<Constructable<Logger>>): this;
    /**
     * Disposes the Injector object and all its disposable injectables
     */
    dispose(): Promise<void>;
    /**
     * Options object for an injector instance
     */
    options: {
        parent?: Injector;
        owner?: any;
    };
    /**
     * Static class metadata map, filled by the @Injectable() decorator
     */
    static meta: Map<Constructable<any>, {
        dependencies: Array<Constructable<any>>;
        options: import('./injectable').InjectableOptions;
    }>;
    readonly cachedSingletons: Map<Constructable<any>, any>;
    remove: <T>(ctor: Constructable<T>) => boolean;
    /**
     *
     * @param ctor The constructor object (e.g. MyClass)
     * @param dependencies Resolved dependencies (usually provided by the framework)
     */
    getInstance<T>(ctor: Constructable<T>, dependencies?: Array<Constructable<T>>): T;
    /**
     * Sets explicitliy an instance for a key in the store
     * @param instance The created instance
     * @param key The class key to be persisted (optional, calls back to the instance's constructor)
     */
    setExplicitInstance<T extends object>(instance: T, key?: Constructable<any>): void;
    /**
     * Creates a child injector instance
     * @param options Additional injector options
     */
    createChild(options?: Partial<Injector['options']>): Injector;
}
//# sourceMappingURL=injector.d.ts.map