# HG changeset patch
# User cin
# Date 2020-07-07 16:41:38
# Node ID 1b124b65514a9362d5c3da2b8986c0494d55000c
# Parent  86e3aa3c3eea2e405ff98c26d5a99ede96bef392

improved interfaces and more tight type checking

diff --git a/src/main/ts/di/ActivationContext.ts b/src/main/ts/di/ActivationContext.ts
--- a/src/main/ts/di/ActivationContext.ts
+++ b/src/main/ts/di/ActivationContext.ts
@@ -1,23 +1,23 @@
 import { TraceSource } from "../log/TraceSource";
-import { argumentNotNull, argumentNotEmptyString, isPrimitive, each, isNull } from "../safe";
-import { Descriptor, ServiceMap, PartialServiceMap } from "./interfaces";
+import { argumentNotNull, argumentNotEmptyString } from "../safe";
+import { Descriptor, ContainerProvided, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
 import { Container } from "./Container";
 import { MapOf } from "../interfaces";
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
-export interface ActivationContextInfo<S> {
+export interface ActivationContextInfo<S extends object> {
     name: string;
 
     service: string;
 
-    scope: PartialServiceMap<S>;
+    scope: ContainerServiceMap<S>;
 }
 
-export class ActivationContext<S> {
+export class ActivationContext<S extends object> {
     _cache: MapOf<any>;
 
-    _services: PartialServiceMap<S>;
+    _services: ContainerServiceMap<S>;
 
     _stack: ActivationContextInfo<S>[];
 
@@ -29,7 +29,7 @@ export class ActivationContext<S> {
 
     container: Container<S>;
 
-    constructor(container: Container<S>, services: PartialServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
+    constructor(container: Container<S>, services: ContainerServiceMap<S>, name?: string, cache?: object, visited?: MapOf<any>) {
         argumentNotNull(container, "container");
         argumentNotNull(services, "services");
 
@@ -45,11 +45,11 @@ export class ActivationContext<S> {
         return this._name;
     }
 
-    resolve<K extends keyof S, T extends S[K]>(name: K, def?: T): T {
+    resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
         const d = this._services[name];
 
         if (d !== undefined) {
-            return this.activate(d as Descriptor<S, T>, name.toString());
+            return this.activate(d, name.toString());
         } else {
             if (def !== undefined && def !== null)
                 return def;
@@ -67,7 +67,7 @@ export class ActivationContext<S> {
     register<K extends keyof S>(name: K, service: Descriptor<S, S[K]>) {
         argumentNotEmptyString(name, "name");
 
-        this._services[name] = service;
+        this._services[name] = service as any;
     }
 
     clone() {
diff --git a/src/main/ts/di/AggregateDescriptor.ts b/src/main/ts/di/AggregateDescriptor.ts
--- a/src/main/ts/di/AggregateDescriptor.ts
+++ b/src/main/ts/di/AggregateDescriptor.ts
@@ -3,7 +3,7 @@ import { ActivationContext } from "./Act
 import { isPrimitive } from "../safe";
 import { isDescriptor } from "./traits";
 
-export class AggregateDescriptor<S, T> implements Descriptor<S, T> {
+export class AggregateDescriptor<S extends object, T> implements Descriptor<S, T> {
     _value: any;
 
     constructor(value: any) {
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
@@ -26,10 +26,10 @@ type ExtractDependency<D, S> = D extends
 type WalkDependencies<D, S> = D extends primitive ? D :
     { [K in keyof D]: ExtractDependency<D[K], S> };
 
-export class Builder<T, S> {
+export class Builder<T, S extends object> {
     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> };
+
         };
     }
 
@@ -54,7 +54,7 @@ export class Builder<T, S> {
 
 }
 
-interface Declaration<S> {
+interface Declaration<S extends object> {
     define<T>(): Builder<T, S>;
 
     dependency<K extends keyof S>(name: K, opts: { lazy: true }): Lazy<K>;
@@ -63,13 +63,15 @@ interface Declaration<S> {
     config(): Config<S>;
 }
 
-interface ServiceModule<T, S> {
-    service: Builder<T, S>;
-}
+type ServiceModule<T, S extends object, M extends string = "service"> = {
+    [m in M]: 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 interface Config<S extends object, Y extends keyof S = keyof S> {
+    register<K extends Y>(name: K, builder: Builder<S[K], S>): Config<S, Exclude<Y, K>>;
+    register<K extends Y>(name: K, m: Promise<ServiceModule<S[K], S>>): Config<S, Exclude<Y, K>>;
+    register<K extends Y, M extends string>(name: K, m: Promise<ServiceModule<S[K], S, M>>, x: M): Config<S, Exclude<Y, K>>;
+
 }
 
 export declare function declare<S extends object>(): Declaration<S>;
diff --git a/src/main/ts/di/Configuration.ts b/src/main/ts/di/Configuration.ts
--- a/src/main/ts/di/Configuration.ts
+++ b/src/main/ts/di/Configuration.ts
@@ -1,9 +1,11 @@
 import {
     PartialServiceMap,
-    ActivationType
+    ActivationType,
+    ContainerKeys,
+    ContainerResolve
 } from "./interfaces";
 
-import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get } from "../safe";
+import { argumentNotEmptyString, isPrimitive, isPromise, delegate, argumentOfType, argumentNotNull, get, primitive } from "../safe";
 import { AggregateDescriptor } from "./AggregateDescriptor";
 import { ValueDescriptor } from "./ValueDescriptor";
 import { Container } from "./Container";
@@ -14,23 +16,23 @@ import { TraceSource } from "../log/Trac
 import { ConfigError } from "./ConfigError";
 import { Cancellation } from "../Cancellation";
 import { makeResolver } from "./ResolverHelper";
-import { ICancellation, Constructor, Factory } from "../interfaces";
+import { ICancellation } from "../interfaces";
 import { isDescriptor } from "./traits";
 
-export interface RegistrationScope<S> {
+export interface RegistrationScope<S extends object> {
 
     /** сервисы, которые регистрируются в контексте активации и таким образом
      * могут переопределять ранее зарегистрированные сервисы. за это свойство
      * нужно платить, кроме того порядок активации будет влиять на результат
      * разрешения зависимостей.
      */
-    services?: PartialServiceMap<S>;
+    services?: RegistrationMap<S>;
 }
 
 /**
  * Базовый интефейс конфигурации сервисов
  */
-export interface ServiceRegistration<T, P, S> extends RegistrationScope<S> {
+export interface ServiceRegistration<T, P, S extends object> extends RegistrationScope<S> {
 
     activation?: ActivationType;
 
@@ -41,13 +43,13 @@ export interface ServiceRegistration<T, 
     cleanup?: ((instance: T) => void) | string;
 }
 
-export interface TypeRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
+export interface TypeRegistration<T, P extends any[], S extends object> extends ServiceRegistration<T, P, S> {
     $type: string | (new (...params: P) => T);
 
 }
 
-export interface FactoryRegistration<T, P extends any[], S> extends ServiceRegistration<T, P, S> {
-    $factory: string | ( (...params: P) => T);
+export interface FactoryRegistration<T, P extends any[], S extends object> extends ServiceRegistration<T, P, S> {
+    $factory: string | ((...params: P) => T);
 }
 
 export interface ValueRegistration<T> {
@@ -55,13 +57,27 @@ export interface ValueRegistration<T> {
     parse?: boolean;
 }
 
-export interface DependencyRegistration<S, K extends keyof S> extends RegistrationScope<S> {
+export interface DependencyRegistration<S extends object, K extends ContainerKeys<S> = ContainerKeys<S>> extends RegistrationScope<S> {
     $dependency: K;
     lazy?: boolean;
     optional?: boolean;
-    default?: S[K];
+    default?: ContainerResolve<S, K>;
 }
 
+export type Registration<T, S extends object> = T extends primitive ? T :
+    (
+        T |
+        { [k in keyof T]: Registration<T[k], S> } |
+        TypeRegistration<T, any, S> |
+        FactoryRegistration<T, any, S> |
+        ValueRegistration<any> |
+        DependencyRegistration<S, keyof S>
+    );
+
+export type RegistrationMap<S extends object> = {
+    [k in keyof S]?: Registration<S[k], S>;
+};
+
 const _activationTypes: { [k in ActivationType]: number; } = {
     singleton: 1,
     container: 2,
@@ -82,7 +98,7 @@ export function isValueRegistration(x: a
     return (!isPrimitive(x)) && ("$value" in x);
 }
 
-export function isDependencyRegistration<S>(x: any): x is DependencyRegistration<S, keyof S> {
+export function isDependencyRegistration<S extends object>(x: any): x is DependencyRegistration<S, keyof S> {
     return (!isPrimitive(x)) && ("$dependency" in x);
 }
 
@@ -112,11 +128,11 @@ async function mapAll(data: any, map?: (
 
 export type ModuleResolver = (moduleName: string, ct?: ICancellation) => any;
 
-export class Configuration<S> {
+export class Configuration<S extends object> {
 
     _hasInnerDescriptors = false;
 
-    _container: Container<S>;
+    readonly _container: Container<S>;
 
     _path: Array<string>;
 
@@ -152,13 +168,13 @@ export class Configuration<S> {
         );
     }
 
-    async applyConfiguration(data: object, contextRequire?: any, ct = Cancellation.none) {
+    async applyConfiguration(data: RegistrationMap<S>, contextRequire?: any, ct = Cancellation.none) {
         argumentNotNull(data, "data");
 
         await this._applyConfiguration(data, await makeResolver(void (0), contextRequire), ct);
     }
 
-    async _applyConfiguration(data: object, resolver?: ModuleResolver, ct = Cancellation.none) {
+    async _applyConfiguration(data: RegistrationMap<S>, resolver?: ModuleResolver, ct = Cancellation.none) {
         trace.log("applyConfiguration");
 
         this._configName = "$";
@@ -213,16 +229,13 @@ export class Configuration<S> {
         return this._require(moduleName);
     }
 
-    async _visitRegistrations(data: any, name: string) {
+    async _visitRegistrations(data: RegistrationMap<S>, name: string) {
         this._enter(name);
 
         if (data.constructor &&
             data.constructor.prototype !== Object.prototype)
             throw new Error("Configuration must be a simple object");
 
-        const o: PartialServiceMap<S> = {};
-        const keys = Object.keys(data);
-
         const services = await mapAll(data, async (v, k) => {
             const d = await this._visit(v, k.toString());
             return isDescriptor(d) ? d : new AggregateDescriptor(d);
@@ -298,7 +311,7 @@ export class Configuration<S> {
         return v;
     }
 
-    _makeServiceParams<T, P>(data: ServiceRegistration<T, P, S>) {
+    _makeServiceParams(data: ServiceRegistration<any, any, S>) {
         const opts: any = {
             owner: this._container
         };
diff --git a/src/main/ts/di/Container.ts b/src/main/ts/di/Container.ts
--- a/src/main/ts/di/Container.ts
+++ b/src/main/ts/di/Container.ts
@@ -1,17 +1,17 @@
 import { ActivationContext } from "./ActivationContext";
 import { ValueDescriptor } from "./ValueDescriptor";
 import { ActivationError } from "./ActivationError";
-import { ServiceMap, Descriptor, PartialServiceMap, ContainerServices, Resolver } from "./interfaces";
+import { ServiceMap, Descriptor, PartialServiceMap, ContainerProvided, Resolver, ContainerServiceMap, ContainerKeys, ContainerResolve } from "./interfaces";
 import { TraceSource } from "../log/TraceSource";
-import { Configuration } from "./Configuration";
+import { Configuration, RegistrationMap } from "./Configuration";
 import { Cancellation } from "../Cancellation";
 import { MapOf } from "../interfaces";
 import { isDescriptor } from "./traits";
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
-export class Container<S = any> implements Resolver<S> {
-    readonly _services: PartialServiceMap<ContainerServices<S>>;
+export class Container<S extends object = any> implements Resolver<S> {
+    readonly _services: ContainerServiceMap<S>;
 
     readonly _cache: MapOf<any>;
 
@@ -41,7 +41,7 @@ export class Container<S = any> implemen
         return this._parent;
     }
 
-    resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T {
+    resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K> {
         trace.debug("resolve {0}", name);
         const d = this._services[name];
         if (d === undefined) {
@@ -53,7 +53,7 @@ export class Container<S = any> implemen
 
             const context = new ActivationContext<S>(this, this._services);
             try {
-                return context.activate(d as Descriptor<S, T>, name.toString());
+                return context.activate(d, name.toString());
             } catch (error) {
                 throw new ActivationError(name.toString(), context.getStack(), error);
             }
@@ -63,7 +63,7 @@ export class Container<S = any> implemen
     /**
      * @deprecated use resolve() method
      */
-    getService<K extends keyof S, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T) {
+    getService<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>) {
         return this.resolve(name, def);
     }
 
@@ -111,7 +111,7 @@ export class Container<S = any> implemen
      *  The function which will be used to load a configuration or types for services.
      *
      */
-    async configure(config: string | object, opts?: any, ct = Cancellation.none) {
+    async configure(config: string | RegistrationMap<S>, opts?: any, ct = Cancellation.none) {
         const c = new Configuration<S>(this);
 
         if (typeof (config) === "string") {
@@ -121,7 +121,7 @@ export class Container<S = any> implemen
         }
     }
 
-    createChildContainer<S2 extends { container?: Container<S & S2> } = S>(): Container<S & S2> {
+    createChildContainer<S2 extends object = S>(): Container<S & S2> {
         return new Container<S & S2>(this as any);
     }
 
diff --git a/src/main/ts/di/FactoryServiceDescriptor.ts b/src/main/ts/di/FactoryServiceDescriptor.ts
--- a/src/main/ts/di/FactoryServiceDescriptor.ts
+++ b/src/main/ts/di/FactoryServiceDescriptor.ts
@@ -1,11 +1,11 @@
 import { ServiceDescriptor, ServiceDescriptorParams } from "./ServiceDescriptor";
 import { argumentNotNull, oid } from "../safe";
 
-export interface FactoryServiceDescriptorParams<S, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
+export interface FactoryServiceDescriptorParams<S extends object, T, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
     factory: (...args: P) => T;
 }
 
-export class FactoryServiceDescriptor<S, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
+export class FactoryServiceDescriptor<S extends object, T, P extends any[]> extends ServiceDescriptor<S, T, P> {
     constructor(opts: FactoryServiceDescriptorParams<S, T, P>) {
         super(opts);
 
diff --git a/src/main/ts/di/ReferenceDescriptor.ts b/src/main/ts/di/ReferenceDescriptor.ts
--- a/src/main/ts/di/ReferenceDescriptor.ts
+++ b/src/main/ts/di/ReferenceDescriptor.ts
@@ -1,30 +1,26 @@
-import { isNull, argumentNotEmptyString, each, keys } from "../safe";
+import { argumentNotEmptyString, each } from "../safe";
 import { ActivationContext } from "./ActivationContext";
-import { ServiceMap, Descriptor, PartialServiceMap } from "./interfaces";
+import { Descriptor, PartialServiceMap, ContainerResolve, ContainerKeys } from "./interfaces";
 import { ActivationError } from "./ActivationError";
 
-export interface ReferenceDescriptorParams<S, K extends keyof S> {
+export interface ReferenceDescriptorParams<S extends object, K extends ContainerKeys<S>> {
     name: K;
     lazy?: boolean;
     optional?: boolean;
-    default?: S[K];
+    default?: ContainerResolve<S, K>;
     services?: PartialServiceMap<S>;
 }
 
-function defined<T>(v: T | undefined) {
-    if (v === undefined)
-        throw Error();
-    return v;
-}
+export class ReferenceDescriptor<S extends object = any, K extends ContainerKeys<S> = ContainerKeys<S>>
+    implements Descriptor<S, ContainerResolve<S, K> | ((args?: PartialServiceMap<S>) => ContainerResolve<S, K>)> {
 
-export class ReferenceDescriptor<S = any, K extends keyof S = keyof S> implements Descriptor<S, S[K] | ((args?: PartialServiceMap<S> ) => S[K])> {
     _name: K;
 
     _lazy = false;
 
     _optional = false;
 
-    _default: S[K] | undefined;
+    _default: ContainerResolve<S, K> | undefined;
 
     _services: PartialServiceMap<S>;
 
@@ -35,7 +31,7 @@ export class ReferenceDescriptor<S = any
         this._optional = !!opts.optional;
         this._default = opts.default;
 
-        this._services = (opts.services || {}) as ServiceMap<S>;
+        this._services = (opts.services || {}) as PartialServiceMap<S>;
     }
 
     activate(context: ActivationContext<S>) {
diff --git a/src/main/ts/di/ServiceDescriptor.ts b/src/main/ts/di/ServiceDescriptor.ts
--- a/src/main/ts/di/ServiceDescriptor.ts
+++ b/src/main/ts/di/ServiceDescriptor.ts
@@ -9,7 +9,7 @@ let cacheId = 0;
 
 const trace = TraceSource.get("@implab/core/di/ActivationContext");
 
-function injectMethod<T, M extends keyof T, S, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
+function injectMethod<T, M extends keyof T, S extends object, A>(target: T, method: M, context: ActivationContext<S>, args: A) {
 
     const m = target[method];
     if (!m || typeof m !== "function")
@@ -59,7 +59,7 @@ export type InjectionSpec<T> = {
     [m in keyof T]?: any;
 };
 
-export interface ServiceDescriptorParams<S, T, P extends any[]> {
+export interface ServiceDescriptorParams<S extends object, T, P extends any[]> {
     activation?: ActivationType;
 
     owner: Container<S>;
@@ -73,7 +73,7 @@ export interface ServiceDescriptorParams
     cleanup?: Cleaner<T>;
 }
 
-export class ServiceDescriptor<S, T, P extends any[]> implements Descriptor<S, T> {
+export class ServiceDescriptor<S extends object, T, P extends any[]> implements Descriptor<S, T> {
     _instance: T | undefined;
 
     _hasInstance = false;
diff --git a/src/main/ts/di/TypeServiceDescriptor.ts b/src/main/ts/di/TypeServiceDescriptor.ts
--- a/src/main/ts/di/TypeServiceDescriptor.ts
+++ b/src/main/ts/di/TypeServiceDescriptor.ts
@@ -2,11 +2,11 @@ import { ServiceDescriptor, ServiceDescr
 import { Constructor, Factory } from "../interfaces";
 import { argumentNotNull, isPrimitive } from "../safe";
 
-export interface TypeServiceDescriptorParams<S, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
+export interface TypeServiceDescriptorParams<S extends object, T extends object, P extends any[]> extends ServiceDescriptorParams<S, T, P> {
     type: Constructor<T>;
 }
 
-export class TypeServiceDescriptor<S, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
+export class TypeServiceDescriptor<S extends object, T extends object, P extends any[]> extends ServiceDescriptor<S, T, P> {
     _type: Constructor;
 
     constructor(opts: TypeServiceDescriptorParams<S, T, P>) {
diff --git a/src/main/ts/di/interfaces.ts b/src/main/ts/di/interfaces.ts
--- a/src/main/ts/di/interfaces.ts
+++ b/src/main/ts/di/interfaces.ts
@@ -1,21 +1,38 @@
 import { ActivationContext } from "./ActivationContext";
 
-export interface Descriptor<S = any, T = any> {
+export interface Descriptor<S extends object = any, T = any> {
     activate(context: ActivationContext<S>): T;
 }
 
-export type ServiceMap<S> = {
+export type ServiceMap<S extends object> = {
     [k in keyof S]: Descriptor<S, S[k]>;
 };
 
-export type PartialServiceMap<S> = {
+export type ContainerKeys<S extends object> = keyof S | keyof ContainerProvided<S>;
+
+export type ContainerResolve<S extends object, K> =
+    K extends keyof ContainerProvided<S> ? ContainerProvided<S>[K] :
+    K extends keyof S ? S[K] : never;
+
+export type ContainerServiceMap<S extends object> = {
+    [K in ContainerKeys<S>]: Descriptor<S, ContainerResolve<S, K>>;
+};
+
+export type PartialServiceMap<S extends object> = {
     [k in keyof S]?: Descriptor<S, S[k]>;
 };
 
-export interface Resolver<S> {
-    resolve<K extends keyof ContainerServices<S>, T extends ContainerServices<S>[K] = ContainerServices<S>[K]>(name: K, def?: T): T;
+export interface Resolver<S extends object> {
+    resolve<K extends ContainerKeys<S>>(name: K, def?: ContainerResolve<S, K>): ContainerResolve<S, K>;
+}
+
+export interface ContainerProvided<S extends object> {
+    container: Resolver<S>;
 }
-export type ContainerServices<S> = S & {
-    container: Resolver<S>;
-};
+
+export type ContainerRegistered<S extends object> = /*{
+    [K in Exclude<keyof S, keyof ContainerProvided<S>>]: S[K];
+};*/
+    Exclude<S, ContainerProvided<S>>;
+
 export type ActivationType = "singleton" | "container" | "hierarchy" | "context" | "call";
diff --git a/src/main/ts/di/traits.ts b/src/main/ts/di/traits.ts
--- a/src/main/ts/di/traits.ts
+++ b/src/main/ts/di/traits.ts
@@ -4,4 +4,4 @@ import { Descriptor } from "./interfaces
 export function isDescriptor(x: any): x is Descriptor {
     return (!isPrimitive(x)) &&
         (x.activate instanceof Function);
-}
+}
\ No newline at end of file
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
@@ -2,5 +2,5 @@ import { config } from "./services";
 
 config()
     .register("bar", import("./Bar"))
-    .register("box", import("./Box"))
-    .register("foo", import("./Foo"), "Foo");
+    .register("box", import("./Box"), "service");
+    //.register("foo", import("./Foo"), "Foo");
diff --git a/src/test/ts/tests/ContainerTests.ts b/src/test/ts/tests/ContainerTests.ts
--- a/src/test/ts/tests/ContainerTests.ts
+++ b/src/test/ts/tests/ContainerTests.ts
@@ -6,10 +6,17 @@ import { ValueDescriptor } from "../di/V
 import { Foo } from "../mock/Foo";
 import { Bar } from "../mock/Bar";
 import { isNull } from "../safe";
-import { Descriptor } from "../di/interfaces";
+import { Box } from "ts/mock/Box";
 
 test("Container register/resolve tests", async t => {
-    const container = new Container();
+    const container = new Container<{
+        "bla-bla": string;
+        "connection": string;
+        "dbParams": {
+            timeout: number;
+            connection: string;
+        }
+    }>();
 
     const connection1 = "db://localhost";
 
@@ -42,7 +49,11 @@ test("Container register/resolve tests",
 
 test("Container configure/resolve tests", async t => {
 
-    const container = new Container();
+    const container = new Container<{
+        foo: Foo;
+        box: Bar;
+        bar: Bar;
+    }>();
 
     await container.configure({
         foo: {