# HG changeset patch
# User cin
# Date 2022-05-23 08:51:26
# Node ID 154d88dba49c476908cf80d3ab322ae3a60e9960
# Parent  a51ea59f042305d0df920608d2f6a0ffbb2967d2

code comments

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,21 +1,41 @@
 import { DescriptorBuilder } from "./DescriptorBuilder";
-import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, RequiredKeys } from "./interfaces";
+import { ConfigurableKeys, ContainerServices, ConfigurableServices, RegistrationBuildersMap, ExtractRequired } from "./interfaces";
 import { ServiceContainer } from "./interfaces";
 import { argumentNotNull, each, isKey } from "./traits";
 
 export class FluentConfiguration<S extends object, Y extends ConfigurableKeys<S> = ConfigurableKeys<S>> {
 
-    _builders: Partial<RegistrationBuildersMap<S>> = {};
+    private _builders: Partial<RegistrationBuildersMap<S>> = {};
 
+    /** Adds a declaration of the services to the current config.
+     * 
+     * @template D The map of the services
+     * @returns self
+     */
     declare<D extends Partial<Pick<S, keyof D & keyof S>>>(): FluentConfiguration<S & D, Y | ConfigurableKeys<D>> {
         return this as FluentConfiguration<S & D, Y | ConfigurableKeys<D>>;
     }
 
+    /** Adds compile-time information about the already provided services
+     * 
+     * @template P The map of the provided services
+     * @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>>;
     }
 
+    /** Register the service.
+     * 
+     * @param name The name of the service
+     * @param builder The service builder
+     * @returns self
+     */
     register<K extends Y>(name: K, builder: RegistrationBuildersMap<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]) {
         if (isKey(nameOrConfig)) {
@@ -28,9 +48,16 @@ export class FluentConfiguration<S exten
         return this as FluentConfiguration<S, Exclude<Y, K>>;
     }
 
-    done(missing: RequiredKeys<S, Y> extends never ? void : RequiredKeys<S, Y>) {
-        if (missing !== undefined)
-            throw new Error("The configuration isn't complete");
+    /**
+     * This method is used to enable a compile time check of the configuration.
+     * If there are not configured services in the configuration the compiler
+     * will trigger the error.
+     * 
+     * @param missing Empty object literal should always be specified.
+     * @returns self
+     */
+    // eslint-disable-next-line @typescript-eslint/no-unused-vars
+    done<M extends ExtractRequired<S,Y>>(missing: M) {
         return this;
     }
 
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
@@ -117,5 +117,5 @@ export interface ILifetime<T> {
     store(item: T, cleanup?: (item: T) => void): void;
 }
 
-export type RequiredKeys<T, K extends keyof T = keyof T> = keyof { [p in K as (T[p] extends undefined ? never : p)]-?: T[p] };
+export type ExtractRequired<T, K extends keyof T = keyof T> = { [p in K as (undefined extends T[p] ? never : p)]-?: T[p] };
 
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
@@ -49,7 +49,7 @@ const config = fluent()
         foo: it => it.factory($ => new Foo()),
         baz: it => it.value(new Foo())
     })
-    .done();
+    .done({});
 
     declare const container: Container<SharedServices>;