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
@@ -4,13 +4,13 @@ export interface ActivationItem {
 }
 
 export class ActivationError {
-    activationStack: ActivationItem[];
+    readonly activationStack: ActivationItem[];
 
-    service: string;
+    readonly service: string;
 
-    innerException: unknown;
+    readonly innerException: unknown;
 
-    message: string;
+    readonly message: string;
 
     constructor(service: string, activationStack: ActivationItem[], innerException: unknown) {
         this.message = "Failed to activate the service";
diff --git a/src/main/ts/ContextResolver.ts b/src/main/ts/ContextResolver.ts
deleted file mode 100644
--- a/src/main/ts/ContextResolver.ts
+++ /dev/null
@@ -1,19 +0,0 @@
-import { ActivationContext } from "./ActivationContext";
-
-export class ContextResolver<S extends object> {
-    private readonly _context: ActivationContext<S>;
-
-    constructor(context: ActivationContext<S>) {
-        this._context = context;
-    }
-
-    resolve<K extends keyof S, O extends { lazy: true}>(name: K, opts?: O): () => (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
-    resolve<K extends keyof S, O extends { lazy?: false}>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
-    resolve(name: keyof S, opts?: {lazy?: boolean, default?: unknown}) {
-        if (opts && opts.lazy) {
-            return () => "default" in opts ? this._context.resolve(name, opts.default) : this._context.resolve(name);
-        } else {
-            return opts && "default" in opts ? this._context.resolve(name, opts.default) : this._context.resolve(name);
-        }
-    }
-}
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,26 +1,28 @@
-import { Resolver, RegistrationBuilder, LifetimeContainer, ConfigurableKeys } from "./interfaces";
+import { RegistrationBuilder, LifetimeContainer, ConfigurableKeys, IDescriptorBuilder, Ref, Resolved, DepsMap } from "./interfaces";
 import { Descriptor, ILifetime, ActivationType } from "./interfaces";
 import { DescriptorImpl, RegistrationOverridesMap } from "./DescriptorImpl";
 import { LifetimeManager } from "./LifetimeManager";
-import { each, isKey, isPromise, isString, oid } from "./traits";
+import { each, isKey, isPromise, isString, key, oid } from "./traits";
 
 /**
  * @template {S} Карта доступных зависимостей, как правило `ContainerServices`
  * @template {T} Тип сервиса
  */
-export class DescriptorBuilder<S extends object, T> {
+export class DescriptorBuilder<S extends object, T, R extends object = object> implements IDescriptorBuilder<S, T, R> {
     private readonly _lifetimeContainer: LifetimeContainer;
     private readonly _cb: (d: Descriptor<S, T>) => void;
 
     private readonly _eb: (err: unknown) => void;
 
+    private readonly _refs: DepsMap<key, keyof S>;
+
     private _lifetime = LifetimeManager.empty<T>();
 
     private _overrides: RegistrationOverridesMap<S>;
 
     private _cleanup?: (item: T) => void;
 
-    private _factory?: (resolve: Resolver<S>) => T;
+    private _factory?: (refs: R) => T;
 
     private _pending = 1;
 
@@ -41,7 +43,32 @@ export class DescriptorBuilder<S extends
         this._cb = cb;
         this._eb = eb;
         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;
+        }> {
+
+        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;
+        }>;
+    }
+    factory(f: (refs: R) => T): void {
+        this._assertBuilding();
+        this._factory = f;
+        this._finalize();
+        this._complete();
+    }
+
 
     private _assertBuilding() {
         if (this._finalized)
@@ -103,12 +130,12 @@ export class DescriptorBuilder<S extends
         return this;
     }
 
-    factory(f: (resolve: Resolver<S>) => T): void {
+    /*factory(f: (resolve: Resolver<S>) => T): void {
         this._assertBuilding();
         this._factory = f;
         this._finalize();
         this._complete();
-    }
+    }*/
 
     value(v: T): void {
         this._assertBuilding();
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,18 +1,19 @@
-import { Descriptor, ILifetime, ConfigurableKeys, Resolver } from "./interfaces";
+import { Descriptor, ILifetime, ConfigurableKeys, DepsMap, Ref } from "./interfaces";
 import { ActivationContext } from "./ActivationContext";
-import { ContextResolver } from "./ContextResolver";
-import { each } from "./traits";
+import { each, isKey, key } from "./traits";
 
 export type RegistrationOverridesMap<S extends object> = { [k in ConfigurableKeys<S>]?: Descriptor<S, NonNullable<S[k]>> };
 
 export interface DescriptorImplArgs<S extends object, T> {
     lifetime: ILifetime<T>;
 
-    factory: (resolve: Resolver<S>) => T;
+    factory: (refs: Record<key, never>) => T;
 
     cleanup?: (item: T) => void;
 
     overrides?: RegistrationOverridesMap<S>;
+
+    dependencies?: DepsMap<key, keyof S>;
 }
 
 
@@ -22,17 +23,21 @@ export class DescriptorImpl<S extends ob
 
     private readonly _lifetime: ILifetime<T>;
 
-    private readonly _factory: (resolve: Resolver<S>) => T;
+    private readonly _factory: (refs: Record<key, never>) => T;
 
     private readonly _cleanup?: (item: T) => void;
 
-    constructor(args: DescriptorImplArgs<S, T>) {
-        this._lifetime = args.lifetime;
-        this._factory = args.factory;
-        if (args.cleanup)
-            this._cleanup = args.cleanup;
-        if (args.overrides)
-            this._overrides = args.overrides;
+    private readonly _deps?: DepsMap<key, keyof S>;
+
+    constructor({ lifetime, factory, cleanup, overrides, dependencies }: DescriptorImplArgs<S, T>) {
+        this._lifetime = lifetime;
+        this._factory = factory;
+        if (cleanup)
+            this._cleanup = cleanup;
+        if (overrides)
+            this._overrides = overrides;
+        if (dependencies)
+            this._deps = dependencies;
     }
 
     activate(context: ActivationContext<S>): T {
@@ -45,11 +50,26 @@ export class DescriptorImpl<S extends ob
         if (this._overrides)
             each(this._overrides, (v, k) => context.register(k, v));
 
-
-        const resolver = new ContextResolver(context);
+        const resolve = <K extends keyof S, L extends boolean, D = never>({ name, lazy, ...opts }: Ref<K, L, D>) => {
+            if (lazy) {
+                return () => "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
+            } else {
+                return "default" in opts ? context.resolve(name, opts.default) : context.resolve(name);
+            }
+        };
 
+        const makeRefs = (deps?: DepsMap<key, keyof S>) => deps ?
+            Object.keys(deps)
+                .map(k => {
+                    const ref = deps[k];
+                    return isKey(ref) ?
+                        { [k]: resolve({ name: ref }) } :
+                        { [k]: resolve(ref) };
+                })
+                .reduce((a, p) => ({ ...a, ...p }), {} ) as Record<key, never>:
+            {} as Record<key, never>;
 
-        const instance = this._factory.call(undefined, resolver.resolve.bind(resolver));
+        const instance = this._factory.call(undefined, makeRefs(this._deps));
 
         this._lifetime.store(instance, this._cleanup);
 
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
@@ -62,21 +62,20 @@ export class FluentConfiguration<S exten
     }
 
 
-    apply<A extends Partial<S>>(target: ServiceContainer<A>) {
+    apply<T extends ServiceContainer<S>>(target: T) {
 
         let pending = 1;
 
-        const _t2 = target as ServiceContainer<S>;
-
         const reject = (ex: unknown) => { throw ex; };
 
         const complete = () => !--pending;
 
         each(this._builders, (v, k) => {
             pending++;
-            const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(_t2,
+            const d = new DescriptorBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[typeof k]>>(
+                target,
                 result => {
-                    _t2.register(k, result);
+                    target.register(k, result);
                     complete();
                 },
                 reject
@@ -88,7 +87,7 @@ export class FluentConfiguration<S exten
         if (!complete())
             throw new Error("The configuration didn't complete.");
 
-        return _t2 as ServiceContainer<A & S>;
+        return target as T & ServiceContainer<S>;
     }
 
 }
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
@@ -1,4 +1,5 @@
 import { ActivationContext } from "./ActivationContext";
+import { key } from "./traits";
 
 export type primitive = number | string | null | undefined | symbol;
 
@@ -29,13 +30,28 @@ export interface Resolver<S extends obje
     <K extends keyof S, O extends { lazy?: false; default?: unknown }>(name: K, opts?: O): (O extends { default: infer T } ? T : never) | NonNullable<S[K]>;
 }
 
-export interface DescriptorBuilder<S extends object, T> {
+export type DepsMap<K extends key, SK extends key> = { [k in K]: SK | Ref<SK, boolean, unknown> };
+
+export type Ref<K extends key, L extends boolean, D> = { name: K, lazy?: L} | { name: K, lazy?: L, default: D };
+
+export type Resolved<S, K extends keyof S, L, D> =
+    L extends true ? () => NonNullable<S[K]> | (unknown extends D ? never : D) : NonNullable<S[K]> |  (unknown extends D ? never : D);
+
+export interface IDescriptorBuilder<S extends object, T, R extends object = object> {
 
     /**
      * 
      * @param f
      */
-    factory(f: (resolve: Resolver<S>) => T): void;
+    factory(f: (refs: R) => T): void;
+
+    wants<X extends DepsMap<Exclude<key, keyof R>, keyof S>>(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
+        }>
 
     override<K extends ConfigurableKeys<S>>(name: K, builder: RegistrationBuilder<S, NonNullable<S[K]>>): this;
     override<K extends ConfigurableKeys<S>>(services: { [name in K]: RegistrationBuilder<S, NonNullable<S[K]>> }): this;
@@ -48,7 +64,7 @@ export interface DescriptorBuilder<S ext
     value(v: T): void;
 }
 
-export type RegistrationBuilder<S extends object, T> = (d: DescriptorBuilder<S, T>) => void;
+export type RegistrationBuilder<S extends object, T> = (d: IDescriptorBuilder<S, T>) => void;
 
 export type RegistrationBuildersMap<S extends object, K extends ConfigurableKeys<S> = ConfigurableKeys<S>> = {
     [k in K]-?: RegistrationBuilder<ContainerServices<S>, NonNullable<ConfigurableServices<S>[k]>>
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
@@ -1,7 +1,6 @@
 /* eslint max-classes-per-file: ["error", 20] */
 import { describe, it } from "mocha";
-import {LifetimeManager} from "../LifetimeManager";
-import {Container} from "../Container";
+import { Container } from "../Container";
 import { fluent } from "../traits";
 
 class Foo {
@@ -11,7 +10,7 @@ class Foo {
 class Bar {
     bar = "bar";
 
-    constructor(foo?: () => Foo) {}
+    constructor(foo?: () => Foo) { }
 }
 
 interface Services {
@@ -44,15 +43,23 @@ const config = fluent()
     .declare<ServicesB>()
     .register({
         bar: it => it
-            .lifetime("context")
-            .factory($ => new Bar($("zoo", {lazy: true, default: new Foo()}))),
-        foo: it => it.factory($ => new Foo()),
+            .lifetime("context") // тип активации, время жизни
+            .wants({
+                zoo: "zoo", // зависимость
+
+                zoo$: { name: "zoo", lazy: true } // отложенная активация, 
+                //фабричный метод
+            })
+            .factory(({ zoo$ }) => // фабрика получает объект с именованными зависимостями
+                // удобно для деструктурирования
+                new Bar(zoo$) // создается экземпляр сервиса
+            ),
+        foo: it => it.factory(() => new Foo()),
         baz: it => it.value(new Foo())
     })
     .done({});
 
-    declare const container: Container<SharedServices>;
-
+declare const container: Container<Record<string, never>>;
 const c2 = config.apply(container);
 
-c2.resolve("baz");
\ No newline at end of file
+c2.resolve("foo");
\ No newline at end of file