diff --git a/src/main/ts/di/Annotations.ts b/src/main/ts/di/Annotations.ts
--- a/src/main/ts/di/Annotations.ts
+++ b/src/main/ts/di/Annotations.ts
@@ -1,21 +1,21 @@
-import { Constructor } from "../interfaces";
 import { primitive } from "../safe";
+import { TypeRegistration } from "./Configuration";
 
 export interface InjectOptions {
     lazy?: boolean;
 }
 
-interface Dependency<K extends keyof any> {
+export interface Dependency<K extends keyof any> {
     $dependency: K;
 
     lazy?: boolean;
 }
 
-interface Lazy<K extends keyof any> extends Dependency<K> {
+export interface Lazy<K extends keyof any> extends Dependency<K> {
     lazy: true;
 }
 
-type Compatible<T1, T2> = T1 extends T2 ? any : never;
+type Compatible<T1, T2> = T2 extends T1 ? any : never;
 
 type ExtractService<K, S> = K extends keyof S ? S[K] : K;
 
@@ -26,21 +26,10 @@ type ExtractDependency<D, S> = D extends
 type WalkDependencies<D, S> = D extends primitive ? D :
     { [K in keyof D]: ExtractDependency<D[K], S> };
 
-interface Services<S> {
-    get<K extends keyof S>(name: K): Dependency<K>;
-
-    lazy<K extends keyof S>(name: K): Lazy<K>;
-
-    build<T extends object>(): Builder<T, S>;
-}
-
-export declare function services<S extends object>(): Services<S>;
-
-export declare function build<T = never, S = any>(): Builder<T, S>;
-
 export class Builder<T, S> {
-    consume<P extends any[]>(...args: P) {
+    declare<P extends any[]>(...args: P) {
         return <C extends new (...args: ExtractDependency<P, S>) => T>(constructor: C) => {
+            return constructor as C & { service: Builder<T, S> };
         };
     }
 
@@ -59,17 +48,28 @@ export class Builder<T, S> {
         };
     }
 
-    cast<T2 extends T>(): Builder<T2, S> {
-        return this as Builder<T2, S>;
-    }
-
-    get<K extends keyof S>(name: K): Dependency<K> {
+    getDescriptor(): TypeRegistration<T, any, S> {
         throw new Error();
     }
 
-    lazy<K extends keyof S>(name: K): Lazy<K> {
-        throw new Error();
-    }
+}
+
+interface Declaration<S> {
+    define<T>(): Builder<T, S>;
+
+    dependency<K extends keyof S>(name: K, opts: { lazy: true }): Lazy<K>;
+    dependency<K extends keyof S>(name: K, opts?: any): Dependency<K>;
+
+    config(): Config<S>;
+}
 
+interface ServiceModule<T, S> {
+    service: Builder<T, S>;
+}
 
+interface Config<S> {
+    register<K extends keyof S>(name: K, builder: Builder<S[K], S>): Config<Omit<S, K>>;
+    register<K extends keyof S>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<Omit<S, K>>;
 }
+
+export declare function declare<S extends object>(): Declaration<S>;
diff --git a/src/test/ts/mock/Bar.ts b/src/test/ts/mock/Bar.ts
--- a/src/test/ts/mock/Bar.ts
+++ b/src/test/ts/mock/Bar.ts
@@ -1,12 +1,12 @@
 import { Foo } from "./Foo";
-import { build } from "./config";
+import { define, dependency } from "./services";
 
-const service = build<Bar>();
+export const service = define<Bar>();
 
-@service.consume({
-    foo: service.get("foo"),
+@service.declare({
+    foo: dependency("foo"),
     nested: {
-        lazy: service.lazy("foo")
+        lazy: dependency("foo", {lazy: true})
     }
 })
 export class Bar {
diff --git a/src/test/ts/mock/Box.ts b/src/test/ts/mock/Box.ts
--- a/src/test/ts/mock/Box.ts
+++ b/src/test/ts/mock/Box.ts
@@ -1,17 +1,12 @@
-import { services } from "../di/Annotations";
 import { Bar } from "./Bar";
-import { Foo } from "./Foo";
-
-// declare required dependencies
-const config = services<{
-     bar: Bar;
-     foo: Foo;
-}>();
+import { define, dependency } from "./services";
 
 // export service descriptor
-export const service = config.build<Box<Bar>>();
+// через service передается информация о типе зависимости
+// даже если это шаблон.
+export const service = define<Box<Bar>>();
 
-@service.consume(config.get("bar"))
+@service.declare(dependency("bar"))
 export class Box<T> {
     private _value: T | undefined;
 
@@ -19,13 +14,13 @@ export class Box<T> {
         this._value = value;
     }
 
-    @service.inject( config.get("bar"))
-    setValue(value?: T) {
+    @service.inject(dependency("bar"))
+    setValue(value: T) {
         this._value = value;
         return value;
     }
 
-    setObj(value: object) {
+    setObj(value: any) {
 
     }
 
diff --git a/src/test/ts/mock/config.ts b/src/test/ts/mock/config.ts
--- a/src/test/ts/mock/config.ts
+++ b/src/test/ts/mock/config.ts
@@ -1,27 +1,6 @@
-import { Foo } from "./Foo";
-import { Bar } from "./Bar";
-import { Box } from "./Box";
-import { Builder } from "../di/Annotations";
-
-interface Services {
-    foo: Foo;
-
-    bar: Bar;
-
-    box: Box<Foo>;
-
-    host: string;
+import { config } from "./services";
 
-}
-
-const services = {
-    build: <T>() => {
-        return new Builder<T, Services>();
-    }
-};
-
-namespace services {
-
-}
-
-export = services;
+config()
+    .register("bar", import("./Bar"))
+    .register("box", import("./Box"))
+    .register("foo", import("./Foo"), "Foo");
diff --git a/src/test/ts/mock/services.ts b/src/test/ts/mock/services.ts
new file mode 100644
--- /dev/null
+++ b/src/test/ts/mock/services.ts
@@ -0,0 +1,23 @@
+import { Foo } from "./Foo";
+import { Bar } from "./Bar";
+import { Box } from "./Box";
+import { declare } from "../di/Annotations";
+
+/**
+ * Сервисы доступные внутри контейнера
+ */
+export interface Services {
+    foo: Foo;
+
+    bar: Bar;
+
+    box: Box<Bar>;
+
+    host: string;
+
+}
+
+/**
+ * Экспортируем вспомогательные функции для описания сервисов и кинфогурации
+ */
+export const { define, dependency, config } = declare<Services>();