loi - npm Package Compare versions

Comparing version 0.2.0 to 0.3.0

lib/index.d.ts

 import * as t from 'io-ts';
 export declare type TypeOf<RT extends t.Any> = RT['_A'];
-export { start, BaseFactory } from './types/Base';
-export { any, AnyFactory } from './types/Any';
-export { boolean, BooleanFactory } from './types/Boolean';
-export { number, NumberFactory } from './types/Number';
-export { string, StringFactory } from './types/String';
-export { array, ArrayFactory } from './types/Array';
-export { object, ObjectFactory, InitialObjectFactory } from './types/Object';
+export { start, LoiFactoryBase } from './types/Base';
+export { any, LoiFactoryAny } from './types/Any';
+export { boolean, LoiFactoryBoolean, LoiFactoryBooleanInitial } from './types/Boolean';
+export { number, LoiFactoryNumber } from './types/Number';
+export { string, LoiFactoryString } from './types/String';
+export { array, LoiFactoryArray } from './types/Array';
+export { object, LoiFactoryObject, LoiFactoryObjectInitial } from './types/Object';
+export { enumeration, LoiFactoryEnum } from './types/Enum';
 export declare function validate<S, A>(value: S, type: t.Decoder<S, A>): t.Validation<A>;
+export declare function ensureSameType<X, Y extends X>(): [X, Y];
+export declare function ensureTypeSame<Y extends X, X>(): [X, Y];

lib/index.js

@@ -5,22 +5,26 @@ "use strict";
 exports.start = Base_1.start;
-exports.BaseFactory = Base_1.BaseFactory;
+exports.LoiFactoryBase = Base_1.LoiFactoryBase;
 var Any_1 = require("./types/Any");
 exports.any = Any_1.any;
-exports.AnyFactory = Any_1.AnyFactory;
+exports.LoiFactoryAny = Any_1.LoiFactoryAny;
 var Boolean_1 = require("./types/Boolean");
 exports.boolean = Boolean_1.boolean;
-exports.BooleanFactory = Boolean_1.BooleanFactory;
+exports.LoiFactoryBoolean = Boolean_1.LoiFactoryBoolean;
+exports.LoiFactoryBooleanInitial = Boolean_1.LoiFactoryBooleanInitial;
 var Number_1 = require("./types/Number");
 exports.number = Number_1.number;
-exports.NumberFactory = Number_1.NumberFactory;
+exports.LoiFactoryNumber = Number_1.LoiFactoryNumber;
 var String_1 = require("./types/String");
 exports.string = String_1.string;
-exports.StringFactory = String_1.StringFactory;
+exports.LoiFactoryString = String_1.LoiFactoryString;
 var Array_1 = require("./types/Array");
 exports.array = Array_1.array;
-exports.ArrayFactory = Array_1.ArrayFactory;
+exports.LoiFactoryArray = Array_1.LoiFactoryArray;
 var Object_1 = require("./types/Object");
 exports.object = Object_1.object;
-exports.ObjectFactory = Object_1.ObjectFactory;
-exports.InitialObjectFactory = Object_1.InitialObjectFactory;
+exports.LoiFactoryObject = Object_1.LoiFactoryObject;
+exports.LoiFactoryObjectInitial = Object_1.LoiFactoryObjectInitial;
+var Enum_1 = require("./types/Enum");
+exports.enumeration = Enum_1.enumeration;
+exports.LoiFactoryEnum = Enum_1.LoiFactoryEnum;
 function validate(value, type) {
@@ -30,2 +34,8 @@ return type.decode(value);
 exports.validate = validate;
+function ensureSameType() { return undefined; }
+exports.ensureSameType = ensureSameType;
+;
+function ensureTypeSame() { return undefined; }
+exports.ensureTypeSame = ensureTypeSame;
+;
 //# sourceMappingURL=index.js.map

lib/types/Any.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface IAnyOption extends ILoiOption {
-    name: string;
-    nonNull?: boolean;
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare type LoiFactoryTypeAny<T extends t.Any> = T & LoiFactoryAny<T> & LoiFactoryBase<T>;
+export declare class LoiFactoryAny<T extends t.Any> extends LoiFactory<T> {
+    nonNull(): LoiFactoryTypeAny<t.Type<this["_A"], this["_O"], this["_I"]>>;
 }
-export declare type AnyFactoryType<T extends t.Any> = T & AnyFactory<T> & BaseFactory<T>;
-export declare class AnyFactory<T extends t.Any> extends Factory<T> {
-    static decorate<T extends t.Any>(t: T): AnyFactoryType<T>;
-    nonNull(): AnyFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-}
-export declare const any: (() => AnyFactoryType<t.Type<any, any, t.mixed>>) & t.AnyType;
+export declare const any: (() => LoiFactoryTypeAny<t.Type<any, any, t.mixed>>) & t.AnyType;

lib/types/Any.js

@@ -7,9 +7,10 @@ "use strict";
 const Base_1 = require("./Base");
-class AnyFactory extends factory_1.Factory {
+class LoiFactoryAny extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
     nonNull() {
         const type = t.refinement(this, (i) => i !== undefined && i !== null);
-        return factory_1.metadata(AnyFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryAny.decorate(type), {
             parent: this,
@@ -20,7 +21,7 @@ option: { name: "non-null", nonNull: true }
 }
-exports.AnyFactory = AnyFactory;
+exports.LoiFactoryAny = LoiFactoryAny;
 // tslint:disable-next-line:variable-name
 exports.any = mimic_1.mimic(function any() {
     const type = new t.AnyType();
-    return factory_1.metadata(AnyFactory.decorate(type), {
+    return factory_1.metadata(LoiFactoryAny.decorate(type), {
         tag: "any"
@@ -27,0 +28,0 @@ });

lib/types/Array.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface IArrayOption extends ILoiOption {
-    name: string;
-    length?: number;
-    min?: number;
-    max?: number;
-}
-export declare type ArrayFactoryType<E extends t.Any, T extends t.Any> = T & ArrayFactory<E, T> & BaseFactory<T>;
-export declare class ArrayFactory<E extends t.Any, T extends t.Any> extends Factory<T> {
-    static decorate<E extends t.Any, T extends t.Any>(t: T): ArrayFactoryType<E, T>;
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare type LoiFactoryTypeArray<E extends t.Any, T extends t.Any> = T & LoiFactoryArray<E, T> & LoiFactoryBase<T>;
+export declare class LoiFactoryArray<E extends t.Any, T extends t.Any> extends LoiFactory<T> {
     /**
@@ -17,3 +10,3 @@ * Specifies the exact number of items in the array
      */
-    length(limit: number): ArrayFactoryType<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
+    length(limit: number): LoiFactoryTypeArray<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -23,3 +16,3 @@ * Specifies the maximum number of items in the array
      */
-    max(limit: number): ArrayFactoryType<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
+    max(limit: number): LoiFactoryTypeArray<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -29,4 +22,4 @@ * Specifies the minimum number of items in the array
      */
-    min(limit: number): ArrayFactoryType<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
+    min(limit: number): LoiFactoryTypeArray<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<this["_A"], this["_O"], this["_I"]>>;
 }
-export declare function array<E extends t.Any = t.Any>(elementType: E, name?: string): ArrayFactoryType<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<E["_A"][], E["_O"][], t.mixed>>;
+export declare function array<E extends t.Any = t.Any>(elementType: E, name?: string): LoiFactoryTypeArray<t.Type<E["_A"], E["_O"], E["_I"]>, t.Type<E["_A"][], E["_O"][], t.mixed>>;

lib/types/Array.js

@@ -6,5 +6,6 @@ "use strict";
 const Base_1 = require("./Base");
-class ArrayFactory extends factory_1.Factory {
+class LoiFactoryArray extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
@@ -17,3 +18,3 @@ /**
         const type = t.refinement(this, (i) => i.length == limit);
-        return factory_1.metadata(ArrayFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryArray.decorate(type), {
             parent: this,
@@ -29,3 +30,3 @@ option: { name: `exact ${limit} items`, length: limit }
         const type = t.refinement(this, (i) => i.length <= limit);
-        return factory_1.metadata(ArrayFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryArray.decorate(type), {
             parent: this,
@@ -41,3 +42,3 @@ option: { name: `<=${limit} items`, max: limit }
         const type = t.refinement(this, (i) => i.length >= limit);
-        return factory_1.metadata(ArrayFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryArray.decorate(type), {
             parent: this,
@@ -48,6 +49,6 @@ option: { name: `>=${limit} items`, min: limit }
 }
-exports.ArrayFactory = ArrayFactory;
+exports.LoiFactoryArray = LoiFactoryArray;
 function array(elementType, name = `${elementType.name}[]`) {
     const type = t.array(elementType, name);
-    return factory_1.metadata(ArrayFactory.decorate(type), {
+    return factory_1.metadata(LoiFactoryArray.decorate(type), {
         tag: name
@@ -54,0 +55,0 @@ });

lib/types/Base.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-export interface IBaseOption<T> extends ILoiOption {
-    name: string;
-    default?: T;
-    defaultResolver?: () => T;
-    rescue?: T;
-    rescueResolver?: () => T;
-    nullAsUndefined?: boolean;
-}
-export declare type BaseFactoryUnionType<T extends t.Any> = t.UnionType<(T)[], (T)["_A"], (T)["_O"], t.mixed> & BaseFactory<t.Type<(T)["_A"], (T)["_O"], t.mixed>>;
-export declare type BaseFactoryType<T extends t.Any> = T & BaseFactory<T>;
-export declare class BaseFactory<T extends t.Any> extends Factory<T> {
-    static decorate<T extends t.Any>(t: T): BaseFactoryType<T>;
-    nullAsUndefined(): BaseFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+import { LoiFactory } from '../utilties/factory';
+export declare type LoiFactoryTypeBaseUnion<T extends t.Any> = t.UnionType<(T)[], (T)["_A"], (T)["_O"], t.mixed> & LoiFactoryBase<t.Type<(T)["_A"], (T)["_O"], t.mixed>>;
+export declare type LoiFactoryTypeBase<T extends t.Any> = T & LoiFactoryBase<T>;
+export declare class LoiFactoryBase<T extends t.Any> extends LoiFactory<T> {
+    nullAsUndefined(): LoiFactoryTypeBase<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -20,3 +11,3 @@ * Sets properties default values when calling t.validate() method on models
      */
-    default(value: this['_A']): BaseFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    default(value: this['_A']): LoiFactoryTypeBase<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -26,3 +17,3 @@ * Sets properties default values with resolver functions when calling t.validate() method on models
      */
-    defaultResolver(resolver: () => this['_A']): BaseFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    defaultResolver(resolver: () => this['_A']): LoiFactoryTypeBase<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -32,3 +23,3 @@ * Make it never fails with rescue value
      */
-    rescue(value: this['_A']): BaseFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    rescue(value: this['_A']): LoiFactoryTypeBase<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -38,3 +29,3 @@ * Make it never fails with rescue resolver
      */
-    rescueResolver(resolver: () => this['_A']): BaseFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    rescueResolver(resolver: () => this['_A']): LoiFactoryTypeBase<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -60,19 +51,19 @@ * Return the base io-ts type without Loi decorators.
     clean(): t.Type<T['_A'], T['_O'], T['_I']>;
-    allow<T1 extends t.Any>(t1: T1): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any>(t1: T1, t2: T2): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any>(t1: T1, t2: T2, t3: T3): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any, T15 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']> | t.Type<T15['_A'], T15['_O'], T15['_I']>>;
-    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any, T15 extends t.Any, T16 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16): BaseFactoryUnionType<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']> | t.Type<T15['_A'], T15['_O'], T15['_I']> | t.Type<T16['_A'], T16['_O'], T16['_I']>>;
+    allow<T1 extends t.Any>(t1: T1): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any>(t1: T1, t2: T2): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any>(t1: T1, t2: T2, t3: T3): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any, T15 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']> | t.Type<T15['_A'], T15['_O'], T15['_I']>>;
+    allow<T1 extends t.Any, T2 extends t.Any, T3 extends t.Any, T4 extends t.Any, T5 extends t.Any, T6 extends t.Any, T7 extends t.Any, T8 extends t.Any, T9 extends t.Any, T10 extends t.Any, T11 extends t.Any, T12 extends t.Any, T13 extends t.Any, T14 extends t.Any, T15 extends t.Any, T16 extends t.Any>(t1: T1, t2: T2, t3: T3, t4: T4, t5: T5, t6: T6, t7: T7, t8: T8, t9: T9, t10: T10, t11: T11, t12: T12, t13: T13, t14: T14, t15: T15, t16: T16): LoiFactoryTypeBaseUnion<t.Type<this['_A'], this['_O'], this['_I']> | t.Type<T1['_A'], T1['_O'], T1['_I']> | t.Type<T2['_A'], T2['_O'], T2['_I']> | t.Type<T3['_A'], T3['_O'], T3['_I']> | t.Type<T4['_A'], T4['_O'], T4['_I']> | t.Type<T5['_A'], T5['_O'], T5['_I']> | t.Type<T6['_A'], T6['_O'], T6['_I']> | t.Type<T7['_A'], T7['_O'], T7['_I']> | t.Type<T8['_A'], T8['_O'], T8['_I']> | t.Type<T9['_A'], T9['_O'], T9['_I']> | t.Type<T10['_A'], T10['_O'], T10['_I']> | t.Type<T11['_A'], T11['_O'], T11['_I']> | t.Type<T12['_A'], T12['_O'], T12['_I']> | t.Type<T13['_A'], T13['_O'], T13['_I']> | t.Type<T14['_A'], T14['_O'], T14['_I']> | t.Type<T15['_A'], T15['_O'], T15['_I']> | t.Type<T16['_A'], T16['_O'], T16['_I']>>;
 }
-export declare function start<T extends t.Any = t.Any>(type: T, name?: string): BaseFactoryType<t.Type<T["_A"], T["_O"], T["_I"]>>;
+export declare function start<T extends t.Any = t.Any>(type: T, name?: string): LoiFactoryTypeBase<t.Type<T["_A"], T["_O"], T["_I"]>>;

lib/types/Base.js

@@ -8,3 +8,4 @@ "use strict";
 const rescue_1 = require("../utilties/rescue");
-class BaseFactory extends factory_1.Factory {
+class LoiFactoryBase extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
@@ -15,3 +16,3 @@ return factory_1.decorate(this, t);
         const type = convert_1.nullAsUndefined(this);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -27,3 +28,3 @@ option: { name: `null as undefined`, nullAsUndefined: true }
         const type = default_1.withDefault(this, value);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -39,3 +40,3 @@ option: { name: `with default`, default: value }
         const type = default_1.withDefaultResolver(this, resolver);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -51,3 +52,3 @@ option: { name: `with default`, defaultResolver: resolver }
         const type = rescue_1.withRescue(this, value);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -63,3 +64,3 @@ option: { name: `with rescue`, rescue: value }
         const type = rescue_1.withRescueResolver(this, resolver);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -101,3 +102,3 @@ option: { name: `with rescue`, rescueResolver: resolver }
         const type = t.union([this, ...ts]);
-        return factory_1.metadata(BaseFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBase.decorate(type), {
             parent: this,
@@ -108,6 +109,6 @@ tag: type.name
 }
-exports.BaseFactory = BaseFactory;
+exports.LoiFactoryBase = LoiFactoryBase;
 function start(type, name = type[factory_1.loiTag] || type.name) {
     const clonedType = Object.create(type);
-    return factory_1.metadata(BaseFactory.decorate(clonedType), {
+    return factory_1.metadata(LoiFactoryBase.decorate(clonedType), {
         parent: type,
@@ -114,0 +115,0 @@ tag: name

lib/types/Boolean.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface IBooleanOption extends ILoiOption {
-    name: string;
-    parseString?: boolean;
-    parseNumber?: boolean;
-    only?: boolean;
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare type LoiFactoryTypeBoolean<T extends t.Any> = T & LoiFactoryBoolean<T> & LoiFactoryBase<T>;
+export declare type LoiFactoryTypeBooleanInitial<T extends t.Any> = T & LoiFactoryBooleanInitial<T> & LoiFactoryBoolean<T> & LoiFactoryBase<T>;
+export declare class LoiFactoryBoolean<T extends t.Any> extends LoiFactory<T> {
+    parseString(): LoiFactoryTypeBoolean<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    parseNumber(): LoiFactoryTypeBoolean<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    parse(): LoiFactoryTypeBoolean<t.Type<this["_A"], this["_O"], this["_I"]>>;
 }
-export declare type BooleanFactoryType<T extends t.Any> = T & BooleanFactory<T> & BaseFactory<T>;
-export declare class BooleanFactory<T extends t.Any> extends Factory<T> {
-    static decorate<T extends t.Any>(t: T): BooleanFactoryType<T>;
-    parseString(): BooleanFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    parseNumber(): BooleanFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    parse(): BooleanFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    trueOnly(): BooleanFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    falseOnly(): BooleanFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+export declare class LoiFactoryBooleanInitial<T extends t.Any> extends LoiFactory<T> {
+    trueOnly(violet: true): LoiFactoryTypeBoolean<t.Type<true | undefined, true | undefined, this["_I"]>>;
+    trueOnly(violet?: false): LoiFactoryTypeBoolean<t.Type<true, true, this["_I"]>>;
+    falseOnly(violet: true): LoiFactoryTypeBoolean<t.Type<false | undefined, false | undefined, this["_I"]>>;
+    falseOnly(violet?: false): LoiFactoryTypeBoolean<t.Type<false, false, this["_I"]>>;
 }
-export declare const boolean: (() => BooleanFactoryType<t.Type<boolean, boolean, t.mixed>>) & t.BooleanType;
+export declare const boolean: (() => LoiFactoryTypeBooleanInitial<t.Type<boolean, boolean, t.mixed>>) & t.BooleanType;

lib/types/Boolean.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
-const lodash_1 = require("lodash");
 const convert_1 = require("../utilties/convert");
 const factory_1 = require("../utilties/factory");
+const lodash_1 = require("../utilties/lodash");
 const mimic_1 = require("../utilties/mimic");
@@ -11,5 +11,6 @@ const Base_1 = require("./Base");
 const falseValues = ["false", "f", "no", "n", "off", "0"];
-class BooleanFactory extends factory_1.Factory {
+class LoiFactoryBoolean extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
@@ -25,3 +26,3 @@ parseString() {
         }, (i) => lodash_1.isString(i));
-        return factory_1.metadata(BooleanFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBoolean.decorate(type), {
             parent: this,
@@ -39,3 +40,3 @@ option: { name: `parseString`, parseString: true }
         }, (i) => lodash_1.isNumber(i));
-        return factory_1.metadata(BooleanFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryBoolean.decorate(type), {
             parent: this,
@@ -48,22 +49,37 @@ option: { name: `parseNumber`, parseNumber: true }
     }
-    trueOnly() {
-        const type = t.refinement(this, (i) => i === true);
-        return factory_1.metadata(BooleanFactory.decorate(type), {
+}
+exports.LoiFactoryBoolean = LoiFactoryBoolean;
+class LoiFactoryBooleanInitial extends factory_1.LoiFactory {
+    /** @internal */
+    static decorate(t) {
+        return LoiFactoryBoolean.decorate(Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t)));
+    }
+    trueOnly(violet = false) {
+        let type = t.refinement(this, (i) => i === true);
+        if (violet) {
+            type = convert_1.convert(convert_1.nullAsUndefined(type), () => undefined, (i) => i === false);
+        }
+        return factory_1.metadata(LoiFactoryBoolean.decorate(type), {
             parent: this,
-            option: { name: `true only`, only: true }
+            tag: "true",
+            option: violet ? { name: `violet`, violet: true } : undefined
         });
     }
-    falseOnly() {
-        const type = t.refinement(this, (i) => i === false);
-        return factory_1.metadata(BooleanFactory.decorate(type), {
+    falseOnly(violet = false) {
+        let type = t.refinement(this, (i) => i === false);
+        if (violet) {
+            type = convert_1.convert(convert_1.nullAsUndefined(type), () => undefined, (i) => i === true);
+        }
+        return factory_1.metadata(LoiFactoryBoolean.decorate(type), {
             parent: this,
-            option: { name: `false only`, only: false }
+            tag: "false",
+            option: violet ? { name: `violet`, violet: true } : undefined
         });
     }
 }
-exports.BooleanFactory = BooleanFactory;
+exports.LoiFactoryBooleanInitial = LoiFactoryBooleanInitial;
 // tslint:disable-next-line:variable-name
 exports.boolean = mimic_1.mimic(function boolean() {
     const type = new t.BooleanType();
-    return factory_1.metadata(BooleanFactory.decorate(type), {
+    return factory_1.metadata(LoiFactoryBooleanInitial.decorate(type), {
         tag: "boolean"
@@ -70,0 +86,0 @@ });

lib/types/Number.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface INumberOption extends ILoiOption {
-    name: string;
-    max?: number;
-    min?: number;
-    greater?: number;
-    less?: number;
-    integer?: boolean;
-    finite?: boolean;
-    parseFloat?: boolean;
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare type LoiFactoryTypeNumber<T extends t.Any> = T & LoiFactoryNumber<T> & LoiFactoryBase<T>;
+export declare class LoiFactoryNumber<T extends t.Any> extends LoiFactory<T> {
+    max(limit: number): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    min(limit: number): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    greater(limit: number): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    less(limit: number): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    negative(): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    positive(): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    integer(): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    finite(): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    parseFloat(): LoiFactoryTypeNumber<t.Type<this["_A"], this["_O"], this["_I"]>>;
 }
-export declare type NumberFactoryType<T extends t.Any> = T & NumberFactory<T> & BaseFactory<T>;
-export declare class NumberFactory<T extends t.Any> extends Factory<T> {
-    static decorate<T extends t.Any>(t: T): NumberFactoryType<T>;
-    max(limit: number): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    min(limit: number): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    greater(limit: number): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    less(limit: number): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    negative(): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    positive(): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    integer(): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    finite(): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-    parseFloat(): NumberFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
-}
-export declare const number: (() => NumberFactoryType<t.Type<number, number, t.mixed>>) & t.NumberType;
+export declare const number: (() => LoiFactoryTypeNumber<t.Type<number, number, t.mixed>>) & t.NumberType;

lib/types/Number.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
-const lodash_1 = require("lodash");
 const convert_1 = require("../utilties/convert");
 const factory_1 = require("../utilties/factory");
+const lodash_1 = require("../utilties/lodash");
 const mimic_1 = require("../utilties/mimic");
 const Base_1 = require("./Base");
-class NumberFactory extends factory_1.Factory {
+class LoiFactoryNumber extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
     max(limit) {
         const type = t.refinement(this, (n) => n <= limit);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -22,3 +23,3 @@ option: { name: `<=${limit}`, max: limit }
         const type = t.refinement(this, (n) => n >= limit);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -30,3 +31,3 @@ option: { name: `>=${limit}`, min: limit }
         const type = t.refinement(this, (n) => n > limit);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -38,3 +39,3 @@ option: { name: `>${limit}`, greater: limit }
         const type = t.refinement(this, (n) => n < limit);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -46,3 +47,3 @@ option: { name: `<${limit}`, less: limit }
         const type = t.refinement(this, (n) => n < 0);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -54,3 +55,3 @@ option: { name: `-`, less: 0 }
         const type = t.refinement(this, (n) => n > 0);
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -62,3 +63,3 @@ option: { name: `+`, greater: 0 }
         const type = t.refinement(this, (n) => Number.isSafeInteger(n));
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -70,3 +71,3 @@ option: { name: `integer`, integer: true }
         const type = t.refinement(this, (n) => Number.isFinite(n));
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -78,3 +79,3 @@ option: { name: `finite`, finite: true }
         const type = convert_1.convert(this, (i) => parseFloat(i), (i) => lodash_1.isString(i));
-        return factory_1.metadata(NumberFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryNumber.decorate(type), {
             parent: this,
@@ -85,7 +86,7 @@ option: { name: "parseFloat", parseFloat: true }
 }
-exports.NumberFactory = NumberFactory;
+exports.LoiFactoryNumber = LoiFactoryNumber;
 // tslint:disable-next-line:variable-name
 exports.number = mimic_1.mimic(function number() {
     const type = new t.NumberType();
-    return factory_1.metadata(NumberFactory.decorate(type), {
+    return factory_1.metadata(LoiFactoryNumber.decorate(type), {
         tag: "number"
@@ -92,0 +93,0 @@ });

lib/types/Object.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface IObjectOption extends ILoiOption {
-    name: string;
-    type?: Function;
-    instanceof?: Function;
-    strict?: boolean;
-    violet?: boolean;
-}
-export declare const loiObjectRequired: unique symbol;
-export declare const loiObjectOptional: unique symbol;
-export declare type ObjectFactoryType<R extends t.Props, O extends t.Props, T extends t.Any> = T & ObjectFactory<R, O, T> & BaseFactory<T>;
-export declare type InitialObjectFactoryType<R extends t.Props, O extends t.Props, T extends t.Any> = T & InitialObjectFactory<R, O, T> & ObjectFactory<R, O, T> & BaseFactory<T>;
-export declare class ObjectFactory<R extends t.Props, O extends t.Props, T extends t.Any> extends Factory<T> {
-    [loiObjectRequired]: R;
-    [loiObjectOptional]: O;
-    static decorate<R extends t.Props, O extends t.Props, T extends t.Any>(t: T): ObjectFactoryType<R, O, T>;
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare type LoiFactoryTypeObject<R extends t.Props, O extends t.Props, T extends t.Any> = T & LoiFactoryObject<R, O, T> & LoiFactoryBase<T>;
+export declare type LoiFactoryTypeObjectInitial<R extends t.Props, O extends t.Props, T extends t.Any> = T & LoiFactoryObjectInitial<R, O, T> & LoiFactoryObject<R, O, T> & LoiFactoryBase<T>;
+export declare class LoiFactoryObject<R extends t.Props, O extends t.Props, T extends t.Any> extends LoiFactory<T> {
     type<F>(constructor: {
         new (...args: any[]): F;
-    }): ObjectFactoryType<R, O, t.Type<this["_A"] & F, this["_O"] & F, this["_I"]>>;
+    }): LoiFactoryTypeObject<R, O, t.Type<this["_A"] & F, this["_O"] & F, this["_I"]>>;
     instanceof<F>(constructor: {
         new (...args: any[]): F;
-    }): ObjectFactoryType<R, O, t.Type<this["_A"] & F, this["_O"] & F, this["_I"]>>;
+    }): LoiFactoryTypeObject<R, O, t.Type<this["_A"] & F, this["_O"] & F, this["_I"]>>;
 }
-export declare class InitialObjectFactory<R extends t.Props, O extends t.Props, T extends t.Any> extends Factory<T> {
-    [loiObjectRequired]: R;
-    [loiObjectOptional]: O;
-    static decorate<R extends t.Props, O extends t.Props, T extends t.Any>(t: T): InitialObjectFactoryType<R, O, T>;
-    strict(): ObjectFactoryType<R, O, t.Type<T["_A"], T["_O"], T["_I"]>>;
-    violet(): ObjectFactoryType<R, O, t.Type<T["_A"], T["_O"], T["_I"]>>;
+export declare class LoiFactoryObjectInitial<R extends t.Props, O extends t.Props, T extends t.Any> extends LoiFactory<T> {
+    strict(): LoiFactoryTypeObject<R, O, t.Type<T["_A"], T["_O"], T["_I"]>>;
+    violet(): LoiFactoryTypeObject<R, O, t.Type<T["_A"], T["_O"], T["_I"]>>;
 }
-export declare function object(name?: string): InitialObjectFactoryType<{}, {}, t.Type<{}, {}, t.mixed>>;
-export declare function object<R extends t.Props = {}>(required: R, name?: string): InitialObjectFactoryType<{
+export declare function object(name?: string): LoiFactoryTypeObjectInitial<{}, {}, t.Type<{}, {}, t.mixed>>;
+export declare function object<R extends t.Props = {}>(required: R, name?: string): LoiFactoryTypeObjectInitial<{
     [K in keyof R]: t.Type<R[K]['_A'], R[K]['_O'], R[K]['_I']>;
@@ -41,3 +26,3 @@ }, {}, t.Type<{
 }, t.mixed>>;
-export declare function object<R extends t.Props = {}, O extends t.Props = {}>(required: R, optional: O, name?: string): InitialObjectFactoryType<{
+export declare function object<R extends t.Props = {}, O extends t.Props = {}>(required: R, optional: O, name?: string): LoiFactoryTypeObjectInitial<{
     [K in keyof R]: t.Type<R[K]['_A'], R[K]['_O'], R[K]['_I']>;
@@ -44,0 +29,0 @@ }, {

lib/types/Object.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
-const lodash_1 = require("lodash");
 const factory_1 = require("../utilties/factory");
+const lodash_1 = require("../utilties/lodash");
 const object_1 = require("../utilties/object");
 const Base_1 = require("./Base");
+/** @internal */
 exports.loiObjectRequired = Symbol('loiObjectRequired');
+/** @internal */
 exports.loiObjectOptional = Symbol('loiObjectOptional');
-class ObjectFactory extends factory_1.Factory {
+class LoiFactoryObject extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
     type(constructor) {
         const type = t.refinement(this, (i) => i && i.constructor === constructor);
-        return factory_1.metadata(ObjectFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryObject.decorate(type), {
             parent: this,
@@ -23,3 +26,3 @@ option: { name: `type ${constructor.name}`, type: constructor }
         const type = t.refinement(this, (i) => i instanceof constructor);
-        return factory_1.metadata(ObjectFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryObject.decorate(type), {
             parent: this,
@@ -30,10 +33,11 @@ option: { name: `instanceof ${constructor.name}`, instanceof: constructor }
 }
-exports.ObjectFactory = ObjectFactory;
-class InitialObjectFactory extends factory_1.Factory {
+exports.LoiFactoryObject = LoiFactoryObject;
+class LoiFactoryObjectInitial extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return ObjectFactory.decorate(Base_1.BaseFactory.decorate(factory_1.decorate(this, t)));
+        return LoiFactoryObject.decorate(Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t)));
     }
     strict() {
         const type = object_1.strictInterfaceWithOptionals(this[exports.loiObjectRequired], this[exports.loiObjectOptional], this.name);
-        return factory_1.metadata(ObjectFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryObject.decorate(type), {
             parent: this,
@@ -45,3 +49,3 @@ option: { name: `strict`, strict: true }
         const type = object_1.violetInterfaceWithOptionals(this[exports.loiObjectRequired], this[exports.loiObjectOptional], this.name);
-        return factory_1.metadata(ObjectFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryObject.decorate(type), {
             parent: this,
@@ -52,3 +56,3 @@ option: { name: `violet`, violet: true }
 }
-exports.InitialObjectFactory = InitialObjectFactory;
+exports.LoiFactoryObjectInitial = LoiFactoryObjectInitial;
 function object(a, b, c) {
@@ -91,3 +95,3 @@ let required, optional, name;
     const type = object_1.interfaceWithOptionals(required, optional, name);
-    const decorated = factory_1.metadata(InitialObjectFactory.decorate(type), {
+    const decorated = factory_1.metadata(LoiFactoryObjectInitial.decorate(type), {
         tag: name
@@ -94,0 +98,0 @@ });

lib/types/String.d.ts

 import * as t from 'io-ts';
-import { Factory, ILoiOption } from '../utilties/factory';
-import { BaseFactory } from './Base';
-export interface IStringOption extends ILoiOption {
-    name: string;
-    length?: number;
-    min?: number;
-    max?: number;
-    regex?: RegExp;
-}
-export declare class StringType extends t.Type<string> {
+import { LoiFactory } from '../utilties/factory';
+import { LoiFactoryBase } from './Base';
+export declare class LoiTypeString extends t.Type<string> {
     readonly _tag: 'StringType';
     constructor();
 }
-export declare type StringFactoryType<T extends t.Any> = T & StringFactory<T> & BaseFactory<T>;
-export declare class StringFactory<T extends t.Any> extends Factory<T> {
-    static decorate<T extends t.Any>(t: T): StringFactoryType<T>;
+export declare type LoiFactoryTypeString<T extends t.Any> = T & LoiFactoryString<T> & LoiFactoryBase<T>;
+export declare class LoiFactoryString<T extends t.Any> extends LoiFactory<T> {
     /**
@@ -22,3 +14,3 @@ * Specifies the exact string length required
      */
-    length(limit: number): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    length(limit: number): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -28,3 +20,3 @@ * Specifies the maximum number of string characters
      */
-    max(limit: number): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    max(limit: number): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -34,3 +26,3 @@ * Specifies the minimum number string characters
      */
-    min(limit: number): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    min(limit: number): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -41,3 +33,3 @@ * Defines a regular expression rule
      */
-    regex(pattern: RegExp, name?: string): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    regex(pattern: RegExp, name?: string): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -48,3 +40,3 @@ * Defines a regular expression rule
      */
-    regexp(pattern: RegExp, name?: string): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    regexp(pattern: RegExp, name?: string): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
     /**
@@ -55,4 +47,4 @@ * Defines a regular expression rule
      */
-    pattern(pattern: RegExp, name?: string): StringFactoryType<t.Type<this["_A"], this["_O"], this["_I"]>>;
+    pattern(pattern: RegExp, name?: string): LoiFactoryTypeString<t.Type<this["_A"], this["_O"], this["_I"]>>;
 }
-export declare const string: (() => StringFactoryType<t.Type<string, string, t.mixed>>) & StringType;
+export declare const string: (() => LoiFactoryTypeString<t.Type<string, string, t.mixed>>) & LoiTypeString;

lib/types/String.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
-const lodash_1 = require("lodash");
 const factory_1 = require("../utilties/factory");
+const lodash_1 = require("../utilties/lodash");
 const mimic_1 = require("../utilties/mimic");
 const Base_1 = require("./Base");
-class StringType extends t.Type {
+class LoiTypeString extends t.Type {
     constructor() {
@@ -14,6 +14,7 @@ super('string', (m) => lodash_1.isString(m), (m, c) => (this.is(m) ? t.success(m.toString()) : t.failure(m, c)), t.identity);
 }
-exports.StringType = StringType;
-class StringFactory extends factory_1.Factory {
+exports.LoiTypeString = LoiTypeString;
+class LoiFactoryString extends factory_1.LoiFactory {
+    /** @internal */
     static decorate(t) {
-        return Base_1.BaseFactory.decorate(factory_1.decorate(this, t));
+        return Base_1.LoiFactoryBase.decorate(factory_1.decorate(this, t));
     }
@@ -26,3 +27,3 @@ /**
         const type = t.refinement(this, (i) => i.length == limit);
-        return factory_1.metadata(StringFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryString.decorate(type), {
             parent: this,
@@ -38,3 +39,3 @@ option: { name: `exact ${limit} chars`, length: limit }
         const type = t.refinement(this, (i) => i.length <= limit);
-        return factory_1.metadata(StringFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryString.decorate(type), {
             parent: this,
@@ -50,3 +51,3 @@ option: { name: `<=${limit} chars`, max: limit }
         const type = t.refinement(this, (i) => i.length >= limit);
-        return factory_1.metadata(StringFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryString.decorate(type), {
             parent: this,
@@ -63,3 +64,3 @@ option: { name: `>=${limit} chars`, min: limit }
         const type = t.refinement(this, (i) => i.match(pattern) !== null);
-        return factory_1.metadata(StringFactory.decorate(type), {
+        return factory_1.metadata(LoiFactoryString.decorate(type), {
             parent: this,
@@ -86,10 +87,10 @@ option: { name: name, regexp: pattern }
 }
-exports.StringFactory = StringFactory;
+exports.LoiFactoryString = LoiFactoryString;
 // tslint:disable-next-line:variable-name
 exports.string = mimic_1.mimic(function string() {
-    const type = new StringType();
-    return factory_1.metadata(StringFactory.decorate(type), {
+    const type = new LoiTypeString();
+    return factory_1.metadata(LoiFactoryString.decorate(type), {
         tag: "string"
     });
-}, new StringType());
+}, new LoiTypeString());
 //# sourceMappingURL=String.js.map

lib/utilties/factory.d.ts

 import * as t from 'io-ts';
-export declare const loiTag: unique symbol;
-export declare const loiOption: unique symbol;
-export interface ILoiOption {
-    name?: string;
-}
-export declare class Factory<T extends t.Any> extends t.Type<T['_A'], T['_O'], T['_I']> {
+export declare class LoiFactory<T extends t.Any> extends t.Type<T['_A'], T['_O'], T['_I']> {
     constructor();
-    [loiOption]: ILoiOption[];
 }

lib/utilties/factory.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
+/** @internal */
 exports.loiTag = Symbol('loiTag');
+/** @internal */
 exports.loiOption = Symbol('loiOption');
-class Factory extends t.Type {
+class LoiFactory extends t.Type {
     constructor() {
+        // HACK: [ts] Constructors for derived classes must contain a 'super' call.
         super(undefined, undefined, undefined, undefined);
@@ -12,3 +15,3 @@ throw new Error('The Loi factory class cannot be constructored.');
 }
-exports.Factory = Factory;
+exports.LoiFactory = LoiFactory;
 const factoryMaps = new WeakMap();
@@ -15,0 +18,0 @@ function getFactoryMap(klass) {

lib/utilties/object.js

 "use strict";
 Object.defineProperty(exports, "__esModule", { value: true });
 const t = require("io-ts");
-const lodash_1 = require("lodash");
 const convert_1 = require("./convert");
+const lodash_1 = require("./lodash");
 /** @internal */
@@ -36,3 +36,3 @@ function getNameFromProps(required = {}, optional = {}) {
 function nullablePartial(props, name) {
-    return t.partial(lodash_1.mapValues(props, (i) => convert_1.nullAsUndefined(i)), name);
+    return t.partial(lodash_1.objectMapValues(props, (i) => convert_1.nullAsUndefined(i)), name);
 }
@@ -39,0 +39,0 @@ exports.nullablePartial = nullablePartial;

package.json

 {
   "name": "loi",
-  "version": "0.2.0",
+  "version": "0.3.0",
   "files": [
@@ -13,3 +13,2 @@ "lib"
     "@types/chai": "^4.1.2",
-    "@types/lodash": "^4.14.105",
     "@types/mocha": "^5.2.0",
@@ -24,8 +23,6 @@ "chai": "^4.1.2",
     "tslint": "^5.9.1",
-    "typescript": "^2.7.2"
+    "typescript": "^2.8.3"
   },
   "dependencies": {
-    "fp-ts": "^1.2.0",
-    "io-ts": "^1.0.5",
-    "lodash": "^4.17.5"
+    "io-ts": "^1.1.2"
   },
@@ -32,0 +29,0 @@ "scripts": {

No alert changes

Improved metrics

Total package byte prevSize

91345

increased by14.64%

Dependency count

1

decreased by-66.67%

Dev dependency count

11

decreased by-8.33%

Number of package files

50

increased by13.64%

Lines of code

1231

increased by13.14%

Dependency changes

• - Removedfp-ts@^1.2.0

• - Removedlodash@^4.17.5

• - Removedlodash@4.17.21(transitive)

• Updatedio-ts@^1.1.2