diff --git a/.vscode/settings.json b/.vscode/settings.json
--- a/.vscode/settings.json
+++ b/.vscode/settings.json
@@ -1,3 +1,6 @@
 {
-    "java.configuration.updateBuildConfiguration": "automatic"
+    "java.configuration.updateBuildConfiguration": "automatic",
+    "cSpell.words": [
+        "linkcode"
+    ]
 }
\ No newline at end of file
diff --git a/src/main/ts/ActivationContext.ts b/src/main/ts/ActivationContext.ts
--- a/src/main/ts/ActivationContext.ts
+++ b/src/main/ts/ActivationContext.ts
@@ -1,5 +1,4 @@
-import { Descriptor, ILifetime, RegistrationMap, LifetimeContainer, ConfigurableKeys } from "./interfaces";
-import { LifetimeManager } from "./LifetimeManager";
+import { Descriptor, ILifetime, IActivationContext, DescriptorMap, ILifetimeManager } from "./interfaces";
 import { argumentNotNull } from "./traits";
 
 export interface ActivationContextInfo {
@@ -11,20 +10,25 @@ export interface ActivationContextInfo {
 
 let nextId = 1;
 
-/** This class is created once per `Container.resolve` method call and used to
+/** This object is created once per `Container.resolve` method call and used to
  * cache dependencies and to track created instances. The activation context
  * tracks services with `context` activation type.
+ * 
+ * @template S The service map used in the activation context, services from
+ *   this map are available to resolution.
+ * @template U A set of keys from the service map which can be overridden in
+ *   this activation context.
  */
-export class ActivationContext<S extends object> {
+export class ActivationContext<S> implements IActivationContext<S> {
     private readonly _cache: Record<string, unknown>;
 
-    private readonly _services: Partial<RegistrationMap<S>>;
+    private readonly _services: DescriptorMap<S>;
 
     private readonly _name: string;
 
     private readonly _service: Descriptor<S, unknown>;
 
-    private readonly _containerLifetimeManager: LifetimeManager;
+    private readonly _containerLifetimeManager: ILifetimeManager;
 
     private readonly _parent: ActivationContext<S> | undefined;
 
@@ -36,7 +40,7 @@ export class ActivationContext<S extends
      * @param service the service to activate, this parameter is used for the
      *  debug purpose.
      */
-    constructor(containerLifetimeManager: LifetimeManager, services: Partial<RegistrationMap<S>>, name: string, service: Descriptor<S, unknown>, cache = {}) {
+    constructor(containerLifetimeManager: ILifetimeManager, services: DescriptorMap<S>, name: string, service: Descriptor<S, unknown>, cache = {}) {
         this._name = name;
         this._service = service;
         this._cache = cache;
@@ -53,19 +57,9 @@ export class ActivationContext<S extends
         return this._containerLifetimeManager.create<T>();
     }
 
-    /** Resolves the specified dependency in the current context
-     * @param name The name of the dependency being resolved
-     */
     resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
-    /** Resolves the specified dependency with the specified default value if
-     * the dependency is missing.
-     *
-     * @param name The name of the dependency being resolved
-     * @param def A default value to return in case of the specified dependency
-     *   is missing.
-     */
     resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
-    resolve<K extends keyof S, T>(name: K, def?: T): S[K] | T | undefined {
+    resolve<K extends keyof S, T>(name: K, def?: T): NonNullable<S[K]> | T | undefined {
         const d = this._services[name];
 
         if (d !== undefined) {
@@ -84,18 +78,27 @@ export class ActivationContext<S extends
      * @name{string} the name of the service
      * @service{string} the service descriptor to register
      */
-    register<K extends ConfigurableKeys<S>>(name: K, service: RegistrationMap<S>[K]) {
+    register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]) {
         argumentNotNull(name, "name");
 
+        const d = this._services[name];
+        if (d !== undefined && !d.configurable)
+            throw new Error(`Service ${String(name)} can't be overridden`);
+
         this._services[name] = service;
     }
 
     createLifetime<T>(): ILifetime<T> {
         const id = nextId++;
         return {
-            initialize() {},
+            initialize() { },
             has: () => id in this._cache,
-            get: () => this._cache[id] as T,
+            get: () => {
+                const v = this._cache[id] as T;
+                if (v === undefined || v === null)
+                    throw new Error("The value isn't present in the activation context");
+                return v;
+            },
             store: item => {
                 this._cache[id] = item;
             }
@@ -130,7 +133,9 @@ export class ActivationContext<S extends
     private enter(service: Descriptor<S, unknown>, name: string) {
         return new ActivationContext(
             this._containerLifetimeManager,
-            Object.create(this._services) as typeof this._services,
+            service.hasOverrides ?
+                Object.create(this._services) as typeof this._services :
+                this._services,
             name,
             service,
             this._cache
diff --git a/src/main/ts/ActivationError.ts b/src/main/ts/ActivationError.ts
--- a/src/main/ts/ActivationError.ts
+++ b/src/main/ts/ActivationError.ts
@@ -3,13 +3,32 @@ export interface ActivationItem {
     service: string;
 }
 
+/**
+ * Contains information about the error which occurred during service activation.
+ * 
+ * Information about activation error includes original exception which has
+ * occurred, the name of the service being activated and activation stack of
+ * services.
+ */
 export class ActivationError {
+    /**
+     * Stack of services being activating
+     */
     readonly activationStack: ActivationItem[];
 
+    /**
+     * The name of the failed service
+     */
     readonly service: string;
 
+    /**
+     * The exception which occurred during activation of the service
+     */
     readonly innerException: unknown;
 
+    /**
+     * Error message
+     */
     readonly message: string;
 
     constructor(service: string, activationStack: ActivationItem[], innerException: unknown) {
diff --git a/src/main/ts/Container.ts b/src/main/ts/Container.ts
--- a/src/main/ts/Container.ts
+++ b/src/main/ts/Container.ts
@@ -1,33 +1,54 @@
 import { ActivationContext } from "./ActivationContext";
 import { ActivationError } from "./ActivationError";
 import { ContainerBuilder } from "./ContainerBuilder";
-import { RegistrationMap, ServiceContainer, ContainerServices, ServiceLocator, IContainerBuilder, Configurable, ContainerKeys} from "./interfaces";
-import { LifetimeManager } from "./LifetimeManager";
+import { DescriptorMap, IContainerBuilder, IDestroyable, ILifetimeManager, ServiceLocator } from "./interfaces";
 
-export class Container<S extends Configurable<S>> implements ServiceContainer<S> {
-    private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
+export class Container<S> implements ServiceLocator<S>, IDestroyable {
+    private readonly _services: DescriptorMap<S>;
 
-    private readonly _lifetimeManager: LifetimeManager;
+    private readonly _lifetimeManager: ILifetimeManager;
 
     private _disposed: boolean;
 
-    constructor(services: Partial<RegistrationMap<ContainerServices<S>>>, lifetimeManager: LifetimeManager) {
-        this._services = services;
-        this._services.container = { activate: () => this as ContainerServices<S>["container"]};
-        this._services.childContainer = { activate: () => this.createChildContainer() as ContainerServices<S>["childContainer"] };
+    private readonly _onDestroyed: () => void;
+
+    constructor(services: DescriptorMap<S>, lifetimeManager: ILifetimeManager, destroyed: () => void) {
+        this._services = {
+            ...services,
+            container: {
+                configurable: false,
+                activate: () => this
+            },
+            childContainer: {
+                configurable: false,
+                activate: () => this.createChildBuilder(),
+            }
+        };
+
         this._disposed = false;
         this._lifetimeManager = lifetimeManager;
+        this._onDestroyed = destroyed;
+        
     }
 
-    createChildContainer(): IContainerBuilder<S> {
-        return new ContainerBuilder(this._services);
+    private _assertNotDestroyed() {
+        if (this._disposed)
+            throw new Error("The container is destroyed");
     }
 
-    resolve<K extends keyof ContainerServices<S>>(name: K): NonNullable<ContainerServices<S>[K]>;
-    resolve<K extends keyof ContainerServices<S>, T>(name: K, def: T): NonNullable<ContainerServices<S>[K]> | T;
-    resolve<K extends keyof ContainerServices<S>, T>(name: K, def?: T) {
-        // TODO: add logging
-        // trace.debug("resolve {0}", name);
+    createChildBuilder(): IContainerBuilder<S, keyof S> {
+        this._assertNotDestroyed();
+
+        const lifetime = this._lifetimeManager.create<IDestroyable>();
+
+        return new ContainerBuilder(this._services, lifetime);
+    }
+
+    resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
+    resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
+    resolve<K extends keyof S, T>(name: K, def?: T) {
+        this._assertNotDestroyed();
+
         const d = this._services[name];
         if (d === undefined) {
             if (arguments.length > 1)
@@ -35,7 +56,6 @@ export class Container<S extends Configu
             else
                 throw new Error(`Service '${String(name)}' isn't found`);
         } else {
-
             const context = new ActivationContext(this._lifetimeManager, this._services, String(name), d);
             try {
                 return d.activate(context);
@@ -44,11 +64,11 @@ export class Container<S extends Configu
             }
         }
     }
-
     destroy() {
         if (this._disposed)
             return;
         this._disposed = true;
         this._lifetimeManager.destroy();
+        (0,this._onDestroyed)();
     }
 }
diff --git a/src/main/ts/ContainerBuilder.ts b/src/main/ts/ContainerBuilder.ts
--- a/src/main/ts/ContainerBuilder.ts
+++ b/src/main/ts/ContainerBuilder.ts
@@ -1,42 +1,63 @@
 import { Container } from "./Container";
 import { DescriptorBuilder } from "./DescriptorBuilder";
-import { Configurable, ConfigurableKeys, ContainerServices, Descriptor, IContainerBuilder, IDescriptorBuilder, RegistrationMap, ServiceContainer } from "./interfaces";
-import { LifetimeManager } from "./LifetimeManager";
+import { Descriptor, IContainerBuilder, IDescriptorBuilder, DescriptorMap, ServiceLocator, ILifetime, IDestroyable } from "./interfaces";
+import { emptyLifetime, LifetimeManager } from "./LifetimeManager";
+import { isDestroyable } from "./traits";
 
-export class ContainerBuilder<S extends Configurable<S>> implements IContainerBuilder<S>{
+/**
+ * Container builder used to prepare service descriptors and create a IoC container
+ */
+export class ContainerBuilder<S, U extends keyof S> implements
+    IContainerBuilder<S, U> {
 
     private _pending = 1;
 
-    private readonly _services: Partial<RegistrationMap<ContainerServices<S>>>;
+    private readonly _services: DescriptorMap<S>;
 
     private readonly _lifetimeManager = new LifetimeManager();
 
-    constructor(parentServices?: object) {
-        this._services = Object.create(parentServices ? parentServices : null) as object;
+    private readonly _lifetime: ILifetime<IDestroyable>;
+
+    constructor(parentServices?: DescriptorMap<S>, lifetime?: ILifetime<IDestroyable>) {
+        this._services = Object.create(parentServices ? parentServices : null) as DescriptorMap<S>;
+        this._lifetimeManager = new LifetimeManager();
+        this._lifetime = lifetime ?? emptyLifetime();
     }
+    createServiceBuilder<K extends U>(name: K):
+        IDescriptorBuilder<S, S[K], Record<never, never>, U> {
 
-    createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<ContainerServices<S>, NonNullable<S[K]>, object, keyof S> {
         return new DescriptorBuilder(this._lifetimeManager, this._register(name), this._fail);
+
     }
 
-    build(): ServiceContainer<S> {
+    build(): ServiceLocator<S> {
         this._assertBuilding();
-        if(!this._complete())
+        if (!this._complete())
             throw new Error("The configuration didn't complete.");
-        return new Container(this._services, this._lifetimeManager);
+
+        const lifetime = this._lifetime;
+
+        const detach = isDestroyable(lifetime) ? () => lifetime.destroy() : () => void (0);
+
+        const container = new Container(this._services, this._lifetimeManager, detach);
+        lifetime.store(container);
+
+        return container;
     }
 
-    private readonly _register = <K extends ConfigurableKeys<S>>(name: K) => (descriptor: Descriptor<S, NonNullable<S[K]>>) => {
-        this._complete();
-        this._services[name] = descriptor;
-    };
+    private readonly _register = <K extends U>(name: K) =>
+        (descriptor: Descriptor<S, S[K]>) => {
+            this._complete();
+            this._services[name] = descriptor;
+        };
 
     private readonly _fail = (ex: unknown) => {
-
+        throw ex;
     };
 
     private _assertBuilding() {
-        throw new Error("The descriptor builder is finalized");
+        if (!this._pending)
+            throw new Error("The descriptor builder is finalized");
     }
 
     private _complete() {
diff --git a/src/main/ts/DescriptorBuilder.ts b/src/main/ts/DescriptorBuilder.ts
--- a/src/main/ts/DescriptorBuilder.ts
+++ b/src/main/ts/DescriptorBuilder.ts
@@ -1,28 +1,28 @@
-import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces";
+import { BuildDescriptorFn, IDescriptorBuilder, DepsMap, Resolve, DescriptorMap } from "./interfaces";
 import { Descriptor, ILifetime, ActivationType } from "./interfaces";
-import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
-import { LifetimeManager } from "./LifetimeManager";
-import { each, isKey, isPromise, isString, key, oid } from "./traits";
+import { DescriptorImpl } from "./DescriptorImpl";
+import { contextLifetime, emptyLifetime, hierarchyLifetime, LifetimeManager, singletonLifetime } from "./LifetimeManager";
+import { each, isPromise, isString, key, oid } from "./traits";
 
 /**
  * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
  * @template {T} Тип сервиса
  */
-export class DescriptorBuilder<S extends object, T, R extends object, O extends keyof S> implements IDescriptorBuilder<S, T, R, O> {
+export class DescriptorBuilder<S, T, R, U extends keyof S> implements IDescriptorBuilder<S, T, R, U> {
     private readonly _lifetimeManager: LifetimeManager;
     private readonly _cb: (d: Descriptor<S, T>) => void;
 
     private readonly _eb: (err: unknown) => void;
 
-    private readonly _refs: DepsMap<key, keyof S>;
+    private readonly _refs: DepsMap<R>;
 
-    private _lifetime = LifetimeManager.empty<T>();
+    private _lifetime = emptyLifetime<T>();
 
-    private _overrides: RegistrationOverridesMap<S>;
+    private _overrides: DescriptorMap<S>;
 
     private _cleanup?: (item: T) => void;
 
-    private _factory?: (refs: R) => T;
+    private _factory?: (refs: R) => NonNullable<T>;
 
     private _pending = 1;
 
@@ -45,24 +45,20 @@ export class DescriptorBuilder<S extends
         this._overrides = {};
         this._refs = {};
     }
-    wants<X extends { [k in Exclude<key, keyof R>]: keyof S | Ref<keyof S, boolean, unknown>; }>(refs: X):
-        IDescriptorBuilder<S, T, R & {
-            [k in keyof X]:
-            X[k] extends keyof S ? NonNullable<S[X[k]]> :
-            X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
-            never;
-        }, O> {
+
+    /** Declares dependencies to be consumed in the factory method */
+    wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
+        IDescriptorBuilder<S, T, R & { [k in keyof X]: Resolve<S, X[k]>; }, U> {
 
         each(refs, (v, k) => this._refs[k] = v);
 
         return this as IDescriptorBuilder<S, T, R & {
-            [k in keyof X]:
-            X[k] extends keyof S ? NonNullable<S[X[k]]> :
-            X[k] extends Ref<infer K, infer L, infer D> ? Resolved<S, K & keyof S, L, D> :
-            never;
-        }, O>;
+            [k in keyof X]: Resolve<S, X[k]>;
+        }, U>;
     }
-    factory(f: (refs: R) => T): void {
+
+    /** Registers a factory method for the service */
+    factory(f: (refs: R) => NonNullable<T>): void {
         this._assertBuilding();
         this._factory = f;
         this._finalize();
@@ -79,19 +75,19 @@ export class DescriptorBuilder<S extends
         this._finalized = true;
     }
 
-    override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
-    override<K extends O>(services: { [k in K]: RegistrationBuilder<S, NonNullable<S[k]>> }): this;
-    override<K extends O>(nameOrServices: K | { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }, builder?: RegistrationBuilder<S, NonNullable<S[K]>>): this {
+    override<K extends U>(name: K, builder: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this;
+    override<K extends U>(services: { [k in K]: BuildDescriptorFn<S, NonNullable<S[k]>, U> }): this;
+    override<K extends U>(nameOrServices: K | { [name in K]: BuildDescriptorFn<S, NonNullable<S[K]>, U> }, builder?: BuildDescriptorFn<S, NonNullable<S[K]>, U>): this {
         this._assertBuilding();
         const guard = (v: void | Promise<void>) => {
             if (isPromise(v))
                 v.catch(err => this._fail(err));
         };
 
-        if (isKey(nameOrServices)) {
+        if (typeof nameOrServices !== "object") {
             if (builder) {
                 this._defer();
-                const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, O>(
+                const d = new DescriptorBuilder<S, NonNullable<S[K]>, object, U>(
                     this._lifetimeManager,
                     result => {
                         this._overrides[nameOrServices] = result;
@@ -112,7 +108,13 @@ export class DescriptorBuilder<S extends
         return this;
     }
 
+    /** Specified the singleton lifetime for the service */
     lifetime(lifetime: "singleton", typeId: string): this;
+    /**
+     * Specifies the lifetime for the service, either {@linkcode ILifetime<T>}
+     * object or {@linkcode ActivationType} literal.
+     * @param lifetime 
+     */
     lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
     lifetime(lifetime: ILifetime<T> | ActivationType, typeId?: string): this {
         this._assertBuilding();
@@ -124,13 +126,17 @@ export class DescriptorBuilder<S extends
         return this;
     }
 
+    /** Registers cleanup callback, used when lifetime of the instance is managed
+     * by the container or some external mechanism
+     */
     cleanup(cb: (item: T) => void): this {
         this._assertBuilding();
         this._cleanup = cb;
         return this;
     }
 
-    value(v: T): void {
+    /** Registers a value as the instance of the service */
+    value(v: NonNullable<T>): void {
         this._assertBuilding();
         this._cb({
             activate() {
@@ -145,19 +151,17 @@ export class DescriptorBuilder<S extends
             case "container":
                 return this._lifetimeManager.create();
             case "hierarchy":
-                return LifetimeManager.hierarchyLifetime();
+                return hierarchyLifetime();
             case "context":
-                return LifetimeManager.contextLifetime();
+                return contextLifetime();
             case "singleton": {
                 if (!typeId)
                     throw Error("The singleton activation requires a typeId");
-
                 const _oid = isString(typeId) ? typeId : oid(typeId);
-
-                return LifetimeManager.singletonLifetime(_oid);
+                return singletonLifetime(_oid);
             }
             default:
-                return LifetimeManager.empty();
+                return emptyLifetime();
         }
     }
 
@@ -172,7 +176,7 @@ export class DescriptorBuilder<S extends
 
             this._cb(new DescriptorImpl<S, T>({
                 lifetime: this._lifetime,
-                factory: this._factory,
+                factory: this._factory as (refs: Record<key, unknown>) => NonNullable<T>,
                 overrides: this._overrides,
                 cleanup: this._cleanup
             }));
diff --git a/src/main/ts/DescriptorImpl.ts b/src/main/ts/DescriptorImpl.ts
--- a/src/main/ts/DescriptorImpl.ts
+++ b/src/main/ts/DescriptorImpl.ts
@@ -1,32 +1,32 @@
-import { Descriptor, ILifetime, DepsMap, Ref, IActivationContext } from "./interfaces";
-import { each, isKey, key } from "./traits";
+import { Descriptor, ILifetime, DepsMap, IActivationContext, DescriptorMap } from "./interfaces";
+import { each, key } from "./traits";
 
-export type RegistrationOverridesMap<S extends object> = { [k in keyof S]?: Descriptor<S, NonNullable<S[k]>> };
-
-export interface DescriptorImplArgs<S extends object, T> {
+export interface DescriptorImplArgs<S, T> {
     lifetime: ILifetime<T>;
 
-    factory: (refs: Record<key, never>) => T;
+    factory: (refs: Record<key, unknown>) => NonNullable<T>;
 
-    cleanup?: (item: T) => void;
+    cleanup?: (item: NonNullable<T>) => void;
 
-    overrides?: RegistrationOverridesMap<S>;
+    overrides?: DescriptorMap<S>;
 
-    dependencies?: DepsMap<key, keyof S>;
+    dependencies?: DepsMap<S>;
 }
 
 
-export class DescriptorImpl<S extends object, T> implements Descriptor<S, T> {
+export class DescriptorImpl<S, T> implements Descriptor<S, T> {
 
-    private readonly _overrides?: RegistrationOverridesMap<S>;
+    private readonly _overrides?: DescriptorMap<S>;
 
     private readonly _lifetime: ILifetime<T>;
 
-    private readonly _factory: (refs: Record<key, never>) => T;
+    private readonly _factory: (refs: Record<key, unknown>) => NonNullable<T>;
+
+    private readonly _cleanup?: (item: NonNullable<T>) => void;
 
-    private readonly _cleanup?: (item: T) => void;
+    private readonly _deps?: DepsMap<S>;
 
-    private readonly _deps?: DepsMap<key, keyof S>;
+    readonly hasOverrides: boolean;
 
     constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
         this._lifetime = lifetime;
@@ -37,9 +37,11 @@ export class DescriptorImpl<S extends ob
             this._overrides = overrides;
         if (dependencies)
             this._deps = dependencies;
+
+        this.hasOverrides = !!overrides;
     }
 
-    activate(context: IActivationContext<S>): T {
+    activate(context: IActivationContext<S>): NonNullable<T> {
 
         if (this._lifetime.has())
             return this._lifetime.get();
@@ -49,7 +51,7 @@ export class DescriptorImpl<S extends ob
         if (this._overrides)
             each(this._overrides, (v, k) => context.register(k, v));
 
-        const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
+        const resolve = <K extends keyof S>({ name, lazy, ...opts }: { name: K; lazy?: boolean; default?: S[K] | null; }) => {
             if (lazy) {
                 return () => "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
             } else {
@@ -61,12 +63,12 @@ export class DescriptorImpl<S extends ob
             Object.keys(deps)
                 .map(k => {
                     const ref = deps[k];
-                    return isKey(ref) ?
+                    return typeof ref !== "object" ?
                         { [k]: resolve({ name: ref }) } :
                         { [k]: resolve(ref) };
                 })
-                .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
-            {} as Record<key, never>;
+                .reduce((a, p) => ({ ...a, ...p }), {} ):
+            {};
 
         const instance = this._factory.call(undefined, makeRefs(this._deps));
 
diff --git a/src/main/ts/FluentConfiguration.ts b/src/main/ts/FluentConfiguration.ts
--- a/src/main/ts/FluentConfiguration.ts
+++ b/src/main/ts/FluentConfiguration.ts
@@ -1,19 +1,19 @@
-import { DescriptorBuilder } from "./DescriptorBuilder";
-import { ConfigurableKeys, ContainerServices, RegistrationBuildersMap, ExtractRequired, IContainerBuilder } from "./interfaces";
-import { ServiceContainer } from "./interfaces";
+import {  ConfigurationMap, ConfigurationMapConstraint, ContainerServices, ContainerServicesConstraint, ExtractRequiredKeys, IContainerBuilder } from "./interfaces";
 import { argumentNotNull, each, isKey } from "./traits";
 
-export class FluentConfiguration<S, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
+type ContainerExtensionConstraint<X, S> = ContainerServicesConstraint<Pick<S, keyof X & keyof S>>;
 
-    private _builders: Partial<RegistrationBuildersMap<S>> = {};
+export class FluentConfiguration<S extends ContainerServicesConstraint<S>, Y extends keyof S = keyof S> {
+
+    private _builders: Partial<ConfigurationMap<ContainerServices<S>, keyof S, keyof S>> = {};
 
     /** Adds a declaration of the services to the current config.
      * 
      * @template D The map of the services
      * @returns self
      */
-    declare<D extends Pick<S, keyof D & keyof S>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
-        return this as FluentConfiguration<S & D, Y | ConfigurableKeys<D>>;
+    declare<D extends ContainerExtensionConstraint<D,S>>(): FluentConfiguration<S & D, Y | keyof D> {
+        return this as unknown as FluentConfiguration<S & D, Y | keyof D>;
     }
 
     /** Adds compile-time information about the already provided services
@@ -22,7 +22,7 @@ export class FluentConfiguration<S, Y ex
      * @returns self
      */
     provided<P extends Pick<S, keyof P & keyof S>>(): FluentConfiguration<S & P, Exclude<Y, keyof P>> {
-        return this as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
+        return this as unknown as FluentConfiguration<S & P, Exclude<Y, keyof P>>;
     }
 
     /** Register the service.
@@ -31,13 +31,13 @@ export class FluentConfiguration<S, Y ex
      * @param builder The service builder
      * @returns self
      */
-    register<K extends Y>(name: K, builder: RegistrationBuildersMap<S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, builder: ConfigurationMap<ContainerServices<S>,Y, keyof S>[K]): FluentConfiguration<S, Exclude<Y, K>>;
     /** Registers the collection of services
      * @param config The collection of services to register.
      * @returns self
      */
-    register<K extends Y>(config: RegistrationBuildersMap<S, K>): FluentConfiguration<S, Exclude<Y, K>>;
-    register<K extends Y>(nameOrConfig: K | RegistrationBuildersMap<S, K>, builder?: RegistrationBuildersMap<S>[K]) {
+    register<X extends ConfigurationMapConstraint<ContainerServices<S>, Y, keyof X>>(config: X): FluentConfiguration<S, Exclude<Y, keyof X>>;
+    register<K extends Y>(nameOrConfig: K | ConfigurationMap<ContainerServices<S>, K, keyof S>, builder?: ConfigurationMap<ContainerServices<S>, Y, keyof S>[K]) {
         if (isKey(nameOrConfig)) {
             argumentNotNull(builder, "builder");
             this._builders[nameOrConfig] = builder;
@@ -45,7 +45,7 @@ export class FluentConfiguration<S, Y ex
             each(nameOrConfig, (v, k) => this.register(k, v));
         }
 
-        return this as FluentConfiguration<S, Exclude<Y, K>>;
+        return this; // as FluentConfiguration<S, Exclude<Y, K>>;
     }
 
     /**
@@ -57,15 +57,16 @@ export class FluentConfiguration<S, Y ex
      * @returns self
      */
     // eslint-disable-next-line @typescript-eslint/no-unused-vars
-    done<M extends ExtractRequired<S,Y>>(missing: M) {
+    done(...args: ExtractRequiredKeys<S, Y> extends never ? [] : [services: {[ k in ExtractRequiredKeys<S, Y>]: "required"}]) {
+    //done() {
         return this;
     }
 
-    configure<T extends IContainerBuilder<S>>(builder: T) {
+    configure<C extends IContainerBuilder<ContainerServices<S>, keyof S>>(builder: C) {
         each(this._builders, (v, k) => {
             v(builder.createServiceBuilder(k));
         });
-        builder.build() as T & ServiceContainer<S>;
+        return builder.build();
     }
 
 }
diff --git a/src/main/ts/LifetimeManager.ts b/src/main/ts/LifetimeManager.ts
--- a/src/main/ts/LifetimeManager.ts
+++ b/src/main/ts/LifetimeManager.ts
@@ -1,4 +1,4 @@
-import { IActivationContext, IDestroyable, ILifetime } from "./interfaces";
+import { IActivationContext, ILifetime, ILifetimeManager } from "./interfaces";
 import { ActivationContext } from "./ActivationContext";
 import { argumentNotNull, isDestroyable } from "./traits";
 
@@ -10,7 +10,7 @@ const safeCall = (item: () => void) => {
     }
 };
 
-const emptyLifetime = Object.freeze({
+const _emptyLifetime = Object.freeze({
     has() {
         return false;
     },
@@ -32,7 +32,7 @@ const emptyLifetime = Object.freeze({
 
 });
 
-const unknownLifetime = Object.freeze({
+const _unknownLifetime = Object.freeze({
     has() {
         return false;
     },
@@ -45,6 +45,7 @@ const unknownLifetime = Object.freeze({
     store() {
         throw new Error("Can't store a value in the unknown lifetime object");
     },
+
     toString() {
         return `[object UnknownLifetime]`;
     }
@@ -52,25 +53,25 @@ const unknownLifetime = Object.freeze({
 
 let nextId = 0;
 
-const singletons: { [K:string]: unknown} = {};
+const singletons: { [K: string]: unknown } = {};
 
-export class LifetimeManager implements IDestroyable {
+export class LifetimeManager implements ILifetimeManager {
     private _cleanup: (() => void)[] = [];
-    private readonly _cache: {[K: string]: unknown} = {};
+    private readonly _cache: { [K: string]: unknown } = {};
     private _destroyed = false;
 
-    private readonly _pending: {[K: string]: unknown} = {};
+    private readonly _pending: { [K: string]: unknown } = {};
 
-    create<T>(): ILifetime<T> {
+    create<T>(): ILifetime<T> & { remove(): void; } {
         const id = ++nextId;
         return {
             has: () => id in this._cache,
 
             get: () => {
-                const t = this._cache[id];
-                if (t === undefined)
+                const t = this._cache[id] as T;
+                if (t === undefined || t === null)
                     throw new Error(`The item with with the key ${id} isn't found`);
-                return t as T;
+                return t;
             },
 
             initialize: () => {
@@ -79,23 +80,27 @@ export class LifetimeManager implements 
                 this._pending[id] = true;
             },
 
-            store: (item: T, cleanup?: (item: T) => void) => {
-                argumentNotNull(id, "id");
-                argumentNotNull(item, "item");
-
+            store: (item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) => {
                 if (id in this._cache)
                     throw new Error(`The item with with the key ${id} already registered with this lifetime manager`);
+                if (this._destroyed)
+                    throw new Error("Lifetime manager is destroyed");
+
                 delete this._pending[id];
 
                 this._cache[id] = item;
 
-                if (this._destroyed)
-                    throw new Error("Lifetime manager is destroyed");
                 if (cleanup) {
                     this._cleanup.push(() => cleanup(item));
                 } else if (isDestroyable(item)) {
                     this._cleanup.push(() => item.destroy());
                 }
+            },
+
+            remove: () => {
+                if (this._pending[id])
+                    throw new Error(`The item '${id}' can't be removed before it has been stored`);
+                delete this._cache[id];
             }
         };
     }
@@ -108,104 +113,105 @@ export class LifetimeManager implements 
         }
     }
 
-    static empty<T>(): ILifetime<T> {
-        return emptyLifetime;
-    }
+}
+
+export const emptyLifetime = <T>(): ILifetime<T> => {
+    return _emptyLifetime;
+};
 
-    static hierarchyLifetime<T>() {
-        let _lifetime: ILifetime<T> = unknownLifetime;
-        return {
-            initialize(context: IActivationContext<object>) {
-                if (_lifetime !== unknownLifetime)
-                    throw new Error("Cyclic reference activation detected");
+export const hierarchyLifetime = <T>(): ILifetime<T> => {
+    let _lifetime: ILifetime<T> = _unknownLifetime;
+    return {
+        initialize(context: IActivationContext<object>) {
+            if (_lifetime !== _unknownLifetime)
+                throw new Error("Cyclic reference activation detected");
 
-                _lifetime = context.createContainerLifetime<T>();
-            },
-            get() {
-                return _lifetime.get();
-            },
-            has() {
-                return _lifetime.has();
-            },
-            store(item: T, cleanup?: (item: T) => void) {
-                return _lifetime.store(item, cleanup);
-            },
-            toString() {
-                return `[object HierarchyLifetime, has=${String(this.has())}]`;
-            }
-        };
-    }
-
-    static contextLifetime<T>() {
-        let _lifetime: ILifetime<T> = unknownLifetime;
-        return {
-            initialize(context: ActivationContext<object>) {
-                if (_lifetime !== unknownLifetime)
-                    throw new Error("Cyclic reference detected");
-                _lifetime = context.createLifetime();
-            },
-            get() {
-                return _lifetime.get();
-            },
-            has() {
-                return _lifetime.has();
-            },
-            store(item: T) {
-                _lifetime.store(item);
-            },
-            toString() {
-                return `[object ContextLifetime, has=${String(this.has())}]`;
-            }
-        };
-    }
+            _lifetime = context.createContainerLifetime<T>();
+        },
+        get() {
+            return _lifetime.get();
+        },
+        has() {
+            return _lifetime.has();
+        },
+        store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void) {
+            return _lifetime.store(item, cleanup);
+        },
+        toString() {
+            return `[object HierarchyLifetime, has=${String(this.has())}]`;
+        }
+    };
+};
 
-    static singletonLifetime<T>(typeId: string) {
-        argumentNotNull(typeId, "typeId");
-        let pending = false;
-        return {
-            has() {
-                return typeId in singletons;
-            },
-            get() {
-                if (!this.has())
-                    throw new Error(`The instance ${typeId} doesn't exists`);
-                return singletons[typeId] as T;
-            },
-            initialize() {
-                if (pending)
-                    throw new Error("Cyclic reference detected");
-                pending = true;
-            },
-            store(item: T) {
-                singletons[typeId] = item;
-                pending = false;
-            },
-            toString() {
-                return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
-            }
-        };
-    }
+export const contextLifetime = <T>(): ILifetime<T> => {
+    let _lifetime: ILifetime<T> = _unknownLifetime;
+    return {
+        initialize(context: ActivationContext<object>) {
+            if (_lifetime !== _unknownLifetime)
+                throw new Error("Cyclic reference detected");
+            _lifetime = context.createLifetime();
+        },
+        get() {
+            return _lifetime.get();
+        },
+        has() {
+            return _lifetime.has();
+        },
+        store(item: NonNullable<T>) {
+            _lifetime.store(item);
+        },
+        toString() {
+            return `[object ContextLifetime, has=${String(this.has())}]`;
+        }
+    };
+};
 
-    static containerLifetime<T>(container: { createLifetime<X>(): ILifetime<X>}) {
-        let _lifetime: ILifetime<T> = unknownLifetime;
-        return {
-            initialize() {
-                if (_lifetime !== unknownLifetime)
-                    throw new Error("Cyclic reference detected");
-                _lifetime = container.createLifetime();
-            },
-            get() {
-                return _lifetime.get();
-            },
-            has() {
-                return _lifetime.has();
-            },
-            store(item: T) {
-                _lifetime.store(item);
-            },
-            toString() {
-                return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
-            }
-        };
-    }
-}
+export const singletonLifetime = <T>(typeId: string): ILifetime<T> => {
+    argumentNotNull(typeId, "typeId");
+    let pending = false;
+    return {
+        has() {
+            return typeId in singletons;
+        },
+        get() {
+            if (!this.has())
+                throw new Error(`The instance ${typeId} doesn't exists`);
+            return singletons[typeId] as NonNullable<T>;
+        },
+        initialize() {
+            if (pending)
+                throw new Error("Cyclic reference detected");
+            pending = true;
+        },
+        store(item: NonNullable<T>) {
+            singletons[typeId] = item;
+            pending = false;
+        },
+        toString() {
+            return `[object SingletonLifetime, has=${String(this.has())}, typeId=${typeId}]`;
+        }
+    };
+};
+
+export const containerLifetime = <T>(container: { createLifetime<X>(): ILifetime<X> }) => {
+    let _lifetime: ILifetime<T> = _unknownLifetime;
+    return {
+        initialize() {
+            if (_lifetime !== _unknownLifetime)
+                throw new Error("Cyclic reference detected");
+            _lifetime = container.createLifetime();
+        },
+        get() {
+            return _lifetime.get();
+        },
+        has() {
+            return _lifetime.has();
+        },
+        store(item: NonNullable<T>) {
+            _lifetime.store(item);
+        },
+        toString() {
+            return `[object ContainerLifetime, has=${String(_lifetime.has())}]`;
+        }
+    };
+};
diff --git a/src/main/ts/interfaces.ts b/src/main/ts/interfaces.ts
--- a/src/main/ts/interfaces.ts
+++ b/src/main/ts/interfaces.ts
@@ -11,8 +11,8 @@ export interface Resolver<S> {
     /**
      * Функция для разрешения зависимостей, поддерживает создание фабричных методов,
      * отложенную активацию и значение по-умолчанию для сервисов 
-     * @template K Ключ сервиса из {@link S}
-     * @template O Тип параметра {@link opts} используется для выведения типа
+     * @template K Ключ сервиса из {@linkcode S}
+     * @template O Тип параметра {@linkcode opts} используется для выведения типа
      *   возвращаемого значения.
      * @param name Ключ сервиса, который будет разрешен.
      * @param {boolean=} opts.lazy Признак того, что требуется отложенная активация,
@@ -23,8 +23,8 @@ export interface Resolver<S> {
      * @returns Либо фабричный метод для получения зависимости, либо значение зависимости
      * @throws Error Если зависимость не найдена и не предоставлено значение по-умолчанию
      */
-    <K extends keyof S, O extends { lazy: true; default?: unknown }>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
-    <K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
+    <K extends keyof S, O extends { lazy: true; }>(name: K, opts?: O): () => NonNullable<S[K]> | InferDefault<O>;
+    <K extends keyof S, O extends { lazy?: false; }>(name: K, opts?: O): NonNullable<S[K]> | InferDefault<O>;
 }
 
 export type DepsMap<S> = {
@@ -32,26 +32,52 @@ export type DepsMap<S> = {
 };
 
 export type Refs<S> = {
-    [k in keyof S]: Ref<k, boolean, S[k]>;
+    [k in keyof S]: Ref<k, S[k]>;
 }[keyof S];
 
-export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L, default?: D | null };
+export type Ref<K extends key, D> = {
+    /** The name of the service */
+    name: K;
+
+    /** Make a lazy reference, the resolved dependency will be a function */
+    lazy?: boolean;
+
+    /** The default value for the case where the service isn't defined.
+     * When specified the dependency becomes optional, the default value can be
+     * `null` or `undefined`
+     */
+    default?: D | null
+};
 
 export type Lazy<T, L extends boolean> = L extends true ? () => T : T;
 
+/** Возвращает тип свойства `default` в типе {@link T} */
 export type InferDefault<T> = T extends { default: infer D } ? D : never;
 
+export type InferLazy<R> = R extends { lazy: infer L } ?
+    L extends true ? true : false :
+    false;
 export type Resolve<S, R> =
     R extends keyof S ? NonNullable<S[R]> :
-    R extends Ref<infer K, infer L, unknown> ?
-    K extends keyof S ? Lazy<NonNullable<S[K]> | InferDefault<R>, L> :
+    R extends Ref<infer K, unknown> ?
+    K extends keyof S ?
+    Lazy<NonNullable<S[K]> | InferDefault<R>, InferLazy<R>> :
     never :
     never;
 
 /**
- * Интерфейс для конфигурирования сервиса в контейнере
+ * Интерфейс для конфигурирования сервиса в контейнере. Конфигурирование сервиса
+ * состоит из настройки различных параметров вызовами методов {@linkcode wants},
+ * {@linkcode lifetime}, {@linkcode override}, {@linkcode cleanup}. Завершение настройки
+ * сервиса осуществляется вызовом одного из методов {@linkcode factory} либо 
+ * {@linkcode value}.
+ * 
+ * @template S Карта сервисов контейнера, доступных при описании дескриптора
+ * @template T Тип сервиса
+ * @template R Карта зависимостей, которая передается параметром фабрике
+ * @template U Имена пользовательских сервисов, доступных для переопределения
  */
-export interface IDescriptorBuilder<S, T, R, O extends keyof S> {
+export interface IDescriptorBuilder<S, T, R, U extends keyof S> {
 
     /** Указывает фабрика для создания экземпляра сервиса, фабрика передается
      * в виде параметра. При вызове фабрике будет передан объект с зависимостями,
@@ -59,9 +85,9 @@ export interface IDescriptorBuilder<S, T
      * 
      * Вызов данного метода завершает конфигурирование сервиса.
      * 
-     * @param f Фабрика для создания экземпляра сервиса
+     * @param f Фабрика для создания экземпляра сервиса.
      */
-    factory(f: (refs: R) => T): void;
+    factory(f: (refs: R) => NonNullable<T>): void;
 
     /**
      * Используется для указания зависимостей, которые потребуются фабричному
@@ -78,10 +104,10 @@ export interface IDescriptorBuilder<S, T
     wants<X extends DepsMap<S> & Record<keyof R & keyof X, never>>(refs: X):
         IDescriptorBuilder<S, T, R & {
             [k in keyof X]: Resolve<S, X[k]>;
-        }, O>
+        }, U>
 
-    override<K extends O>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
-    override<K extends O>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
+    override<K extends U>(name: K, builder: BuildDescriptorFn<S, S[K], U>): this;
+    override<X extends ConfigurationMapConstraint<S, U, keyof X>>(services: X): this;
 
     lifetime(lifetime: "singleton", typeId: string | number | object): this;
     lifetime(lifetime: ILifetime<T> | Exclude<ActivationType, "singleton">): this;
@@ -96,49 +122,97 @@ export interface IDescriptorBuilder<S, T
      * 
      * @param v Экземпляр реализации сервиса.
      */
-    value(v: T): void;
+    value(v: NonNullable<T>): void;
 }
 
-export type RegistrationBuilder<S, T> = (d: IDescriptorBuilder<S, T, object, ConfigurableKeys<S>>) => void;
+export type BuildDescriptorFn<S, T, U extends keyof S> = (d: IDescriptorBuilder<S, T, Record<never, never>, U>) => void;
 
-export type RegistrationBuildersMap<S extends Configurable<S>, K extends keyof S = keyof S> = {
-    [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<S[k]>>
+/**
+ * Конфигурация контейнера, состоит из набора функций, которые выполняют конфигурацию.
+ * 
+ * Все параметры конфигурации являются обязательными, если требуется ввести
+ * необязательные параметры, то нужно ограничить параметр типа {@linkcode K}
+ * 
+ * @template S Сервисы доступные в контейнере
+ * @template K Сервисы участвующие в конфигурации
+ */
+export type ConfigurationMap<S, K extends keyof S, U extends keyof S> = {
+    [k in K]-?: BuildDescriptorFn<S, S[k], U>
+};
+
+export type ConfigurationMapConstraint<S, U extends keyof S, X extends string | number | symbol> = {
+    [k in X]-?: k extends U ? BuildDescriptorFn<S, S[k], U> : never;
+};
+
+/**
+ * The type constraint useful to restrict type parameters to prevent defining
+ * the services with the {@link ContainerKeys} names.
+ * 
+ * The constraint doesn't exclude using this keys but declares them as `never`
+ * which effectively will lead using this keys to the error. 
+ */
+export type ContainerServicesConstraint<S> = {
+    [k in keyof S]: k extends ContainerKeys ? never : S[k];
 };
 
 export interface Descriptor<S, T> {
-    activate(context: IActivationContext<S>): T;
+
+    /** This flags indicates that this registration can be replaced or overridden. */
+    readonly configurable?: boolean;
+
+    /** If specified signals the activation context that a new service scope 
+     * should be created to isolate service overrides.
+     */
+    readonly hasOverrides?: boolean;
+
+    activate(context: IActivationContext<S>): NonNullable<T>;
 }
 
 export interface IActivationContext<S> extends ServiceLocator<S> {
     createLifetime<T>(): ILifetime<T>;
 
     createContainerLifetime<T>(): ILifetime<T>;
-}
 
-export type RegistrationMap<S, K extends keyof S = keyof S> = {
-    [k in K]-?: Descriptor<S, S[k]>;
-};
-
-export interface ContainerProvided<S> {
-    container: ServiceLocator<ContainerServices<S>>;
-
-    childContainer: IContainerBuilder<S>;
+    register<K extends keyof S>(name: K, service: DescriptorMap<S>[K]): void;
 }
 
-export type Configurable<S> = { [k in keyof S]: k extends ProvidedKeys ? never : S[k]; };
+/**
+ * Descriptors map for the specified services {@linkcode S}. All entries are
+ * optional regardless the required or optional services in the original map.
+ * 
+ * @template S Сервисы контекста активации
+ * @template U Карта сервисов которые создаются дескрипторами
+ */
+export type DescriptorMap<S> = {
+    [k in keyof S]?: Descriptor<S, S[k]>;
+};
 
-export type ProvidedKeys = keyof ContainerProvided<never>;
+type ContainerKeys = keyof ContainerProvided<object>;
+
+export type ContainerProvided<S extends ContainerServicesConstraint<S>> = {
+    container: ServiceLocator<ContainerServices<S>>;
+
+    childContainer: IContainerBuilder<ContainerServices<S>, Exclude<keyof S, ContainerKeys>>;
+};
 
-export type ContainerServices<S> =
-    { [k in keyof S as k extends ProvidedKeys ? never: k]: S[k] } &
-    ContainerProvided<S>;
 
-export type ConfigurableKeys<S> = Exclude<keyof S, ProvidedKeys>;
+/**
+ * Таблица сервисов, которые предоставляет контейнер.
+ * 
+ * Сервисы, предоставляемые контейнером не могут быть null или undefined.
+ */
+export type ContainerServices<S extends ContainerServicesConstraint<S>> = {
+    [k in keyof S | ContainerKeys]:
+        k extends ContainerKeys ? ContainerProvided<S>[k] :
+        k extends keyof S ? S[k] : never
+};
 
-export type ConfigurableServices<S> = Pick<S, ConfigurableKeys<S>>;
 
-export type ContainerKeys<S> = keyof S | ProvidedKeys;
-
+/**
+ * Returns the service declared in the type map {@link S}.
+ * 
+ * 
+ */
 export interface ServiceLocator<S> {
     resolve<K extends keyof S>(name: K): NonNullable<S[K]>;
     resolve<K extends keyof S, T>(name: K, def: T): NonNullable<S[K]> | T;
@@ -148,17 +222,11 @@ export interface LifetimeContainer {
     createLifetime<T>(): ILifetime<T>;
 }
 
-export interface ServiceContainer<S> extends
-    ServiceLocator<ContainerServices<S>>,
-    IDestroyable {
+export interface IContainerBuilder<S, U extends keyof S> {
+    createServiceBuilder<K extends U>(name: K):
+        IDescriptorBuilder<S, S[K], Record<never, never>, U>;
 
-    createChildContainer(): IContainerBuilder<S>;
-}
-
-export interface IContainerBuilder<S> {
-    createServiceBuilder<K extends keyof S>(name: K): IDescriptorBuilder<S, NonNullable<S[K]>, object, keyof S>;
-
-    build(): ServiceContainer<S>;
+    build(): ServiceLocator<S>;
 }
 
 
@@ -172,12 +240,19 @@ export interface ILifetime<T> {
     /** Проверяет, что уже создан экземпляр объекта */
     has(): boolean;
 
-    get(): T;
+    get(): NonNullable<T>;
+
+    initialize(context: IActivationContext<unknown>): void;
+
+    store(item: NonNullable<T>, cleanup?: (item: NonNullable<T>) => void): void;
 
-    initialize(context: IActivationContext<object>): void;
+    toString(): string;
+}
 
-    store(item: T, cleanup?: (item: T) => void): void;
+export interface ILifetimeManager extends IDestroyable {
+    create<T>(): ILifetime<T>;
 }
 
 export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };
 
+export type ExtractRequiredKeys<T, K extends keyof T = keyof T> = { [p in K]-?: undefined extends T[p] ? never : p }[K];
\ No newline at end of file
diff --git a/src/main/ts/traits.ts b/src/main/ts/traits.ts
--- a/src/main/ts/traits.ts
+++ b/src/main/ts/traits.ts
@@ -1,7 +1,7 @@
 import { FluentConfiguration } from "./FluentConfiguration";
-import { IDestroyable } from "./interfaces";
+import { ContainerServices, ContainerServicesConstraint, IDestroyable } from "./interfaces";
 
-export function fluent<S = {}>() {
+export function fluent<S extends ContainerServicesConstraint<S>>() {
     return new FluentConfiguration<S>();
 }
 
diff --git a/src/test/ts/t/container.ts b/src/test/ts/t/container.ts
--- a/src/test/ts/t/container.ts
+++ b/src/test/ts/t/container.ts
@@ -2,7 +2,7 @@
 import { describe, it } from "mocha";
 import { Container } from "../Container";
 import { ContainerBuilder } from "../ContainerBuilder";
-import { ConfigurableKeys, ContainerProvided, ContainerServices, DepsMap, Refs, Resolver } from "../interfaces";
+import { ContainerServices, DepsMap, IContainerBuilder, Refs, Resolver } from "../interfaces";
 import { fluent } from "../traits";
 
 class Foo {
@@ -22,7 +22,9 @@ interface Services {
 
     baz: Foo;
 
-    container: string;
+    box?: Foo;
+
+    //container: string;
 }
 
 interface ServicesB {
@@ -36,9 +38,9 @@ interface ServicesB {
 
 declare const resolver: Resolver<Services>;
 
-const foo = resolver("foo", {lazy: true});
+const foo = resolver("foo", { lazy: true, default: null });
 
-const mmap = <X extends DepsMap<Services>>(m: X) => {};
+const mmap = <X extends DepsMap<Services>>(m: X) => { };
 
 declare const refs: Refs<Services>;
 
@@ -52,8 +54,8 @@ x.container.resolve("container");
 
 
 mmap({
-   fooz: {name: "foo", lazy: false, default: undefined },
-   ooz: "bar"
+    fooz: { name: "foo", lazy: false, default: undefined },
+    ooz: "bar"
 });
 
 interface SharedServices {
@@ -64,37 +66,42 @@ interface SharedServices {
     baz: Bar;
 }
 
-const config = fluent()
-    .declare<Services>()
+const config = fluent<Services>()
     .declare<ServicesB>()
     .register({
-        zoo: it => {},
+        zoo: it => it.value(new Foo()),
         bar: it => it
             .lifetime("context") // тип активации, время жизни
             .wants({
-                zoo: "zoo", // зависимость
+                self: "container",
+                childContainer: "childContainer",
                 bar: "bar",
-
-                $zoo: { name: "foo", lazy: true, } // отложенная активация, 
-                //фабричный метод
+                foo$: { name: "foo", lazy: true } // отложенная активация, фабричный метод
             })
-            .wants({
-                zoom: "bar"
+            .override({ // переопределение сервиса
+                box: it => it.factory(() => new Foo())
+                
             })
-            .factory(({ $zoo, zoo }) => // фабрика получает объект с именованными зависимостями
-                // удобно для деструктурирования
-                new Bar($zoo) // создается экземпляр сервиса
+            .factory(({ foo$, bar, self, childContainer }) => // фабрика получает объект с именованными зависимостями
+                new Bar(foo$) // создается экземпляр сервиса
             ),
         foo: it => it.factory(() => new Foo()),
-        baz: it => it.value(new Foo())
+        baz: it => it.value(new Foo()),
+        //box: it => it.factory(() => new Foo())
     })
-    .done({});
+    .done();
+
+declare const container: IContainerBuilder<ContainerServices<Services>, keyof Services>;
 
-declare const container: ContainerBuilder<{}>;
+const v = container.build().resolve("foo");
+if (v) {
+    // noop
+}
+
 const c2 = config.configure(container);
 
 c2.resolve("foo");
 
-declare const m :ContainerServices<{foo: Foo}>["container"];
+declare const m: ContainerServices<{ foo?: Foo }>["container"];
 
 m.resolve("container").resolve("container").resolve("foo");
\ No newline at end of file