From 43ffe03a9b62684b06e12ae61f52e61919aa9008 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Sun, 9 Jul 2017 14:52:31 +0300
Subject: [PATCH 1/7] enforce strong typing for partial objects and property
 names

---
 types/seamless-immutable/index.d.ts           |  81 +++++++-----
 .../seamless-immutable-tests.ts               | 123 ++++++++++++------
 2 files changed, 132 insertions(+), 72 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index ceeccd7b3f..046a60259a 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -15,49 +15,60 @@
 export = SeamlessImmutable;
 
 declare namespace SeamlessImmutable {
-  interface MergeConfig {
-    deep?: boolean;
-    merger?: Function;
-  }
+    type DeepPartial<T> = {
+        [P in keyof T]?: DeepPartial<T[P]>;
+    };
 
-  interface Options {
-    prototype?: any;
-  }
+    interface MergeConfig {
+        deep?: boolean;
+        merger?: Function;
+    }
 
-  interface AsMutableOptions {
-    deep: boolean;
-  }
+    interface Options {
+        prototype?: any;
+    }
 
-  export interface ImmutableObject<T> {
-    set(property: string, value: any): ImmutableObject<any>;
-    setIn(propertyPath: Array<string>, value: any): ImmutableObject<any>;
+    interface AsMutableOptions {
+        deep: boolean;
+    }
 
-    asMutable(): T;
-    asMutable(opts: AsMutableOptions): T;
+    export interface ImmutableObject<T> {
+        set<K extends keyof T>(property: K, value: T[K]): T & ImmutableObject<T>;
+        setIn<K extends keyof T>
+            (propertyPath: [ K ], value: T[K]): T & ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K]>
+            (propertyPath: [ K, L ], value: T[K][L]): T & ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
+            (propertyPath: [ K, L, M ], value: T[K][L][M]): T & ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
+            (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): T & ImmutableObject<T>;
 
-    merge(part: any, config?: MergeConfig): ImmutableObject<T>;
+        asMutable(): T;
+        asMutable(opts: AsMutableOptions): T;
 
-    update(property: string, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-    updateIn(propertyPath: Array<string>, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        merge(part: DeepPartial<T>, config?: MergeConfig): T & ImmutableObject<T>;
 
-    without(property: string): ImmutableObject<any>;
-    without(...properties: string[]): ImmutableObject<any>;
-    without(filter: (value: any, key: string) => boolean): ImmutableObject<any>;
-  }
+        update(property: string, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn(propertyPath: Array<string>, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
-  export interface ImmutableArray<T> {
-    asMutable(): Array<T>;
-    asMutable(opts: AsMutableOptions): Array<T>;
-    asObject(toKeyValue: (item: T) => Array<any>): ImmutableObject<T>;
-    flatMap(mapFunction: (item: T) => Array<any>): ImmutableArray<any>;
-  }
+        without(property: string): ImmutableObject<any>;
+        without(...properties: string[]): ImmutableObject<any>;
+        without(filter: (value: any, key: string) => boolean): ImmutableObject<any>;
+    }
 
-  // an immutable object is both of Type T (i.e., looks like a normal T) and of type Immutable<T>
-  export type Immutable<T> = T & (ImmutableObject<T> | ImmutableArray<T>);
+    export interface ImmutableArray<T> {
+        asMutable(): Array<T>;
+        asMutable(opts: AsMutableOptions): Array<T>;
+        asObject(toKeyValue: (item: T) => [string, any]): ImmutableObject<any>;
+        flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): TTarget[] & ImmutableArray<TTarget>;
+    }
 
-  export function from<T>(obj: Array<T>, options?: Options): Array<T> & ImmutableArray<T>;
-  export function from<T>(obj: T, options?: Options): T & ImmutableObject<T>;
+    // an immutable object is both of Type T (i.e., looks like a normal T) and of type Immutable<T>
+    export type Immutable<T> = T & (ImmutableObject<T> | ImmutableArray<T>);
 
-  export function isImmutable(target: any): boolean;
-  export function ImmutableError(message: string): Error;
-}
\ No newline at end of file
+    export function from<T>(obj: Array<T>, options?: Options): Array<T> & ImmutableArray<T>;
+    export function from<T>(obj: T, options?: Options): T & ImmutableObject<T>;
+
+    export function isImmutable(target: any): boolean;
+    export function ImmutableError(message: string): Error;
+}
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 745135b6a9..6ab7fd25be 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -1,51 +1,100 @@
-import SI = require("seamless-immutable");
+import * as Immutable from 'seamless-immutable';
 
-// Immutable instance method test
-const isImmutable: boolean = SI.isImmutable(SI.from([0, 2]));
-const error: Error = SI.ImmutableError("error");
+// Test types
 
-// Immutable Array tests
-const siArray: SI.ImmutableArray<number> = SI.from([0, 1, 2]);
-
-const mutableArray: Array<number> = siArray.asMutable();
-const mutableArray2: Array<number> = siArray.asMutable({ deep: true });
-const arrayToObject: SI.ImmutableObject<number> = siArray.asObject((value: number) =>
-  [value.toString(), value]
-);
-const flatMappedArray: SI.ImmutableArray<number> = siArray.flatMap((value: number) =>
-  [value, value]
-);
-
-// Immutable Object tests
 interface User {
-  firstName: string;
-  lastName: string;
+    firstName: string;
+    lastName: string;
 };
 
 interface Address {
-  line1: string;
+    line1: string;
 }
 
 interface ExtendedUser extends User {
-  address: Address;
+    address: Address;
 }
 
-const siObject: SI.ImmutableObject<User> = SI.from({
-  firstName: "Mike",
-  lastName: "test"
-});
-const extUser: SI.ImmutableObject<ExtendedUser> = siObject.set("address", {
-  line1: "test"
-});
+//
+// Constructors
+// ---------------------------------------------------------------
 
-const updatedAddress: SI.ImmutableObject<ExtendedUser> = extUser.setIn(["address", "line1"], "test2");
-const mutableUser: ExtendedUser = updatedAddress.asMutable();
-const mutableUser2: ExtendedUser = updatedAddress.asMutable({ deep: true });
-const mergedUser: SI.ImmutableObject<User> = siObject.merge({ lastName: "hello" });
-const updatedUser: SI.ImmutableObject<ExtendedUser> = extUser.update("firstName", (firstName): string =>
-  firstName + "hehe"
+{
+    interface User {
+        firstName: string;
+        lastName: string;
+    };
+
+    const arrayOfNumbers: number[] & Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
+    const user: User & Immutable.ImmutableObject<User> = Immutable.from({
+        firstName: 'Angry',
+        lastName: 'Monkey'
+    });
+    const error: Error = Immutable.ImmutableError('error');
+}
+
+//
+// Static utilities
+// ---------------------------------------------------------------
+
+{
+    const isImmutable: boolean = Immutable.isImmutable(Immutable.from([0, 2]));
+}
+
+//
+// Instance syntax: immutable array
+// ---------------------------------------------------------------
+{
+    const array: User[] & Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
+
+    // asMutable
+    const mutableArray1: User[] = array.asMutable();
+    const mutableArray2: User[] = array.asMutable({ deep: true });
+
+    // flatMap
+    const flatMappedArray: User[] & Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
+        [value, value]
+    );
+
+    // asObject
+    const arrayToObject1: Immutable.ImmutableObject<any> = array.asObject((value) => [value.toString(), value]);
+}
+
+//
+// Instance syntax: immutable object
+// ---------------------------------------------------------------
+
+{
+    const immutableUser: Immutable.ImmutableObject<User> = Immutable.from({
+        firstName: 'Pure',
+        lastName: 'Gold'
+    });
+    const immutableUserEx: Immutable.ImmutableObject<ExtendedUser> = Immutable.from({
+        firstName: 'Hairy',
+        lastName: 'Dog',
+        address: {
+            line1: 'Big house'
+        }
+    });
+
+    // set: property name is strongly checked
+    const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
+
+    // setIn: property path is strongly checked for up to 4 arguments
+    const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+
+    // asMutable
+    const mutableUser1: User = immutableUser.asMutable();
+    const mutableUser2: User = immutableUser.asMutable({ deep: true });
+
+    // merge: merged part is strongly checked as a deeply partial object
+    const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
+}
+
+const updatedUser: Immutable.ImmutableObject<ExtendedUser> = extUser.update("firstName", (firstName): string =>
+    firstName + "hehe"
 );
-const updatedInUser: SI.ImmutableObject<ExtendedUser> = extUser.updateIn(["address", "line1"], (line): string =>
-  line + "new address"
+const updatedInUser: Immutable.ImmutableObject<ExtendedUser> = extUser.updateIn(["address", "line1"], (line): string =>
+    line + "new address"
 );
-const userWithoutAddress: SI.ImmutableObject<User> = extUser.without("address");
+const userWithoutAddress: Immutable.ImmutableObject<User> = extUser.without("address");

From 1b91b09021f33ca11d466eb99509b114ebdab5d7 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Sun, 9 Jul 2017 16:49:49 +0300
Subject: [PATCH 2/7] enforce strong typing in update, updateIn, without

---
 types/seamless-immutable/index.d.ts           | 20 +++++++++------
 .../seamless-immutable-tests.ts               | 25 +++++++++++--------
 2 files changed, 27 insertions(+), 18 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index 046a60259a..a121e584f1 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -48,12 +48,19 @@ declare namespace SeamlessImmutable {
 
         merge(part: DeepPartial<T>, config?: MergeConfig): T & ImmutableObject<T>;
 
-        update(property: string, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn(propertyPath: Array<string>, updaterFunction: (value: any, ...additionalParamters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+        updateIn<K extends keyof T>
+            (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K]>
+            (propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
+            (propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
+            (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
 
-        without(property: string): ImmutableObject<any>;
-        without(...properties: string[]): ImmutableObject<any>;
-        without(filter: (value: any, key: string) => boolean): ImmutableObject<any>;
+        without<TTarget>(property: keyof T): TTarget & ImmutableObject<TTarget>;
+        without<TTarget>(...properties: Array<keyof T>): TTarget & ImmutableObject<TTarget>;
+        without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): TTarget & ImmutableObject<TTarget>;
     }
 
     export interface ImmutableArray<T> {
@@ -63,8 +70,7 @@ declare namespace SeamlessImmutable {
         flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): TTarget[] & ImmutableArray<TTarget>;
     }
 
-    // an immutable object is both of Type T (i.e., looks like a normal T) and of type Immutable<T>
-    export type Immutable<T> = T & (ImmutableObject<T> | ImmutableArray<T>);
+    export type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
 
     export function from<T>(obj: Array<T>, options?: Options): Array<T> & ImmutableArray<T>;
     export function from<T>(obj: T, options?: Options): T & ImmutableObject<T>;
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 6ab7fd25be..e5f7411d55 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -78,23 +78,26 @@ interface ExtendedUser extends User {
     });
 
     // set: property name is strongly checked
-    const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
+    const updatedUser: User & Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
 
     // setIn: property path is strongly checked for up to 4 arguments
-    const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+    const updatedUser2: ExtendedUser & Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
 
     // asMutable
     const mutableUser1: User = immutableUser.asMutable();
     const mutableUser2: User = immutableUser.asMutable({ deep: true });
 
     // merge: merged part is strongly checked as a deeply partial object
-    const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
-}
+    const mergedUser: User & Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
 
-const updatedUser: Immutable.ImmutableObject<ExtendedUser> = extUser.update("firstName", (firstName): string =>
-    firstName + "hehe"
-);
-const updatedInUser: Immutable.ImmutableObject<ExtendedUser> = extUser.updateIn(["address", "line1"], (line): string =>
-    line + "new address"
-);
-const userWithoutAddress: Immutable.ImmutableObject<User> = extUser.without("address");
+    // update: property name is strongly checked
+    const updatedUser3: User & Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+
+    // updateIn: property path is strongly checked for up to 4 arguments
+    const updatedUser4: User & Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+
+    // without: the return type must be specified explicitly or it will be `any`
+    const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');
+    const simpleUser2: User & Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
+    const simpleUser3: Immutable.ImmutableObject<any> = immutableUserEx.without('firstName', 'lastName');
+}

From fb798e5fabb9cd792dc27c95ae3e963d02964d6d Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Sun, 9 Jul 2017 18:07:06 +0300
Subject: [PATCH 3/7] final polishing

---
 types/seamless-immutable/index.d.ts           | 46 +++++++++++--------
 .../seamless-immutable-tests.ts               | 24 +++++-----
 types/seamless-immutable/tsconfig.json        |  2 +-
 3 files changed, 40 insertions(+), 32 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index a121e584f1..761f6e460c 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -1,7 +1,9 @@
 // Type definitions for Seamless-immutable 6.1.3
 // Project: https://github.com/rtfeldman/seamless-immutable
 // Definitions by: alex3165 <https://github.com/alex3165>
+//                 Stepan Burguchev <https://github.com/xsburg>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
 // This project is licensed under the MIT license.
 // Copyrights are respective of each contributor listed at the beginning of each definition file.
@@ -32,48 +34,54 @@ declare namespace SeamlessImmutable {
         deep: boolean;
     }
 
-    export interface ImmutableObject<T> {
-        set<K extends keyof T>(property: K, value: T[K]): T & ImmutableObject<T>;
+    interface IImmutableObject<T> {
+        set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
         setIn<K extends keyof T>
-            (propertyPath: [ K ], value: T[K]): T & ImmutableObject<T>;
+            (propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K]>
-            (propertyPath: [ K, L ], value: T[K][L]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L ], value: T[K][L]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
-            (propertyPath: [ K, L, M ], value: T[K][L][M]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L, M ], value: T[K][L][M]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
-            (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
+            (propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
 
         asMutable(): T;
         asMutable(opts: AsMutableOptions): T;
 
-        merge(part: DeepPartial<T>, config?: MergeConfig): T & ImmutableObject<T>;
+        merge(part: DeepPartial<T>, config?: MergeConfig): ImmutableObject<T>;
 
-        update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+        update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T>
-            (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+            (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K]>
-            (propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
-            (propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
-            (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): T & ImmutableObject<T>;
+            (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
+            (propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
-        without<TTarget>(property: keyof T): TTarget & ImmutableObject<TTarget>;
-        without<TTarget>(...properties: Array<keyof T>): TTarget & ImmutableObject<TTarget>;
-        without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): TTarget & ImmutableObject<TTarget>;
+        without<TTarget>(property: keyof T): ImmutableObject<TTarget>;
+        without<TTarget>(...properties: Array<keyof T>): ImmutableObject<TTarget>;
+        without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): ImmutableObject<TTarget>;
     }
 
-    export interface ImmutableArray<T> {
+    interface IImmutableArray<T> {
         asMutable(): Array<T>;
         asMutable(opts: AsMutableOptions): Array<T>;
         asObject(toKeyValue: (item: T) => [string, any]): ImmutableObject<any>;
-        flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): TTarget[] & ImmutableArray<TTarget>;
+        flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): ImmutableArray<TTarget>;
     }
 
+    export type ImmutableObject<T> = T & IImmutableObject<T>;
+    export type ImmutableArray<T> = Array<T> & IImmutableArray<T>;
     export type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
 
-    export function from<T>(obj: Array<T>, options?: Options): Array<T> & ImmutableArray<T>;
-    export function from<T>(obj: T, options?: Options): T & ImmutableObject<T>;
+    export function from<T>(obj: Array<T>, options?: Options): ImmutableArray<T>;
+    export function from<T>(obj: T, options?: Options): ImmutableObject<T>;
 
     export function isImmutable(target: any): boolean;
     export function ImmutableError(message: string): Error;
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index e5f7411d55..1c5beffad6 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -25,8 +25,8 @@ interface ExtendedUser extends User {
         lastName: string;
     };
 
-    const arrayOfNumbers: number[] & Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
-    const user: User & Immutable.ImmutableObject<User> = Immutable.from({
+    const arrayOfNumbers: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
+    const user: Immutable.ImmutableObject<User> = Immutable.from({
         firstName: 'Angry',
         lastName: 'Monkey'
     });
@@ -45,14 +45,14 @@ interface ExtendedUser extends User {
 // Instance syntax: immutable array
 // ---------------------------------------------------------------
 {
-    const array: User[] & Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
+    const array: Immutable.ImmutableArray<User> = Immutable.from<User>([ { firstName: 'Angry', lastName: 'Monkey' } ]);
 
     // asMutable
     const mutableArray1: User[] = array.asMutable();
     const mutableArray2: User[] = array.asMutable({ deep: true });
 
     // flatMap
-    const flatMappedArray: User[] & Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
+    const flatMappedArray: Immutable.ImmutableArray<User> = array.flatMap((value: User) =>
         [value, value]
     );
 
@@ -78,26 +78,26 @@ interface ExtendedUser extends User {
     });
 
     // set: property name is strongly checked
-    const updatedUser: User & Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
+    const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
 
-    // setIn: property path is strongly checked for up to 4 arguments
-    const updatedUser2: ExtendedUser & Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+    // setIn: property path is strongly checked for up to 5 arguments
+    const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
 
     // asMutable
     const mutableUser1: User = immutableUser.asMutable();
     const mutableUser2: User = immutableUser.asMutable({ deep: true });
 
     // merge: merged part is strongly checked as a deeply partial object
-    const mergedUser: User & Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
+    const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
 
     // update: property name is strongly checked
-    const updatedUser3: User & Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+    const updatedUser3: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
 
-    // updateIn: property path is strongly checked for up to 4 arguments
-    const updatedUser4: User & Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+    // updateIn: property path is strongly checked for up to 5 arguments
+    const updatedUser4: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
 
     // without: the return type must be specified explicitly or it will be `any`
     const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');
-    const simpleUser2: User & Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
+    const simpleUser2: Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
     const simpleUser3: Immutable.ImmutableObject<any> = immutableUserEx.without('firstName', 'lastName');
 }
diff --git a/types/seamless-immutable/tsconfig.json b/types/seamless-immutable/tsconfig.json
index 6ca679e6d8..8e2483cd41 100644
--- a/types/seamless-immutable/tsconfig.json
+++ b/types/seamless-immutable/tsconfig.json
@@ -19,4 +19,4 @@
         "index.d.ts",
         "seamless-immutable-tests.ts"
     ]
-}
\ No newline at end of file
+}

From ccd26750c8e01d4caa7ef8520666e07458226539 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Mon, 10 Jul 2017 01:10:45 +0300
Subject: [PATCH 4/7] add fallback definition to solve dynamic scenarios and
 when the number of arguments is more than 5

---
 types/seamless-immutable/index.d.ts            |  2 ++
 .../seamless-immutable-tests.ts                | 18 ++++++++++++++----
 2 files changed, 16 insertions(+), 4 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index 761f6e460c..c027c83429 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -46,6 +46,7 @@ declare namespace SeamlessImmutable {
             (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
             (propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
+        setIn<TValue>(propertyPath: any[], value: TValue): ImmutableObject<T>;
 
         asMutable(): T;
         asMutable(opts: AsMutableOptions): T;
@@ -63,6 +64,7 @@ declare namespace SeamlessImmutable {
             (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
             (propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<TValue>(propertyPath: any[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
         without<TTarget>(property: keyof T): ImmutableObject<TTarget>;
         without<TTarget>(...properties: Array<keyof T>): ImmutableObject<TTarget>;
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 1c5beffad6..8374056fcc 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -76,12 +76,19 @@ interface ExtendedUser extends User {
             line1: 'Big house'
         }
     });
+    const data: {
+        propertyId: string
+    } = {
+        propertyId: 'user.1'
+    };
 
     // set: property name is strongly checked
     const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
 
-    // setIn: property path is strongly checked for up to 5 arguments
+    // setIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
+    // but will fall back to any[] if there are dynamic arguments on the way
     const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+    const updatedUser3: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn([ data.propertyId, 'line1' ], 'Small house');
 
     // asMutable
     const mutableUser1: User = immutableUser.asMutable();
@@ -91,10 +98,13 @@ interface ExtendedUser extends User {
     const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
 
     // update: property name is strongly checked
-    const updatedUser3: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+    const updatedUser4: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
 
-    // updateIn: property path is strongly checked for up to 5 arguments
-    const updatedUser4: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+    // updateIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
+    // but will fall back to any[] if there are dynamic arguments on the way
+    const updatedUser5: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+    // the type of the updated value must be explicity specified in case of fallback
+    const updatedUser6: Immutable.ImmutableObject<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
 
     // without: the return type must be specified explicitly or it will be `any`
     const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');

From bd54249da7ce63587d342ca046ea819a58349bc1 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Mon, 10 Jul 2017 09:25:33 +0300
Subject: [PATCH 5/7] set/update fallbacks, tests, tslint coverage

---
 types/seamless-immutable/index.d.ts           |  2 ++
 .../seamless-immutable-tests.ts               | 23 +++++++++++--------
 types/seamless-immutable/tslint.json          |  1 +
 3 files changed, 16 insertions(+), 10 deletions(-)
 create mode 100644 types/seamless-immutable/tslint.json

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index c027c83429..d40c609dd4 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -36,6 +36,7 @@ declare namespace SeamlessImmutable {
 
     interface IImmutableObject<T> {
         set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
+        set<TValue>(property: string, value: TValue): ImmutableObject<T>;
         setIn<K extends keyof T>
             (propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K]>
@@ -54,6 +55,7 @@ declare namespace SeamlessImmutable {
         merge(part: DeepPartial<T>, config?: MergeConfig): ImmutableObject<T>;
 
         update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        update<TValue>(property: string, updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T>
             (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K]>
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 8374056fcc..64cbfdd6cb 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -5,7 +5,7 @@ import * as Immutable from 'seamless-immutable';
 interface User {
     firstName: string;
     lastName: string;
-};
+}
 
 interface Address {
     line1: string;
@@ -23,7 +23,7 @@ interface ExtendedUser extends User {
     interface User {
         firstName: string;
         lastName: string;
-    };
+    }
 
     const arrayOfNumbers: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
     const user: Immutable.ImmutableObject<User> = Immutable.from({
@@ -83,28 +83,31 @@ interface ExtendedUser extends User {
     };
 
     // set: property name is strongly checked
-    const updatedUser: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
+    const updatedUser01: Immutable.ImmutableObject<User> = immutableUser.set('firstName', 'Whirlwind');
+    const updatedUser02: Immutable.ImmutableObject<User> = immutableUser.set(data.propertyId, 'Whirlwind');
 
     // setIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
     // but will fall back to any[] if there are dynamic arguments on the way
-    const updatedUser2: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
-    const updatedUser3: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn([ data.propertyId, 'line1' ], 'Small house');
+    const updatedUser11: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn(['address', 'line1'], 'Small house');
+    const updatedUser12: Immutable.ImmutableObject<ExtendedUser> = immutableUserEx.setIn([ data.propertyId, 'line1' ], 'Small house');
 
     // asMutable
-    const mutableUser1: User = immutableUser.asMutable();
-    const mutableUser2: User = immutableUser.asMutable({ deep: true });
+    const mutableUser21: User = immutableUser.asMutable();
+    const mutableUser22: User = immutableUser.asMutable({ deep: true });
 
     // merge: merged part is strongly checked as a deeply partial object
     const mergedUser: Immutable.ImmutableObject<User> = immutableUserEx.merge({ address: { line1: 'Small house' }, firstName: 'Jack' });
 
     // update: property name is strongly checked
-    const updatedUser4: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+    const updatedUser41: Immutable.ImmutableObject<User> = immutableUser.update('firstName', x => x.toLowerCase() + ' Whirlwind');
+    // the type of the updated value must be explicity specified in case of fallback
+    const updatedUser42: Immutable.ImmutableObject<User> = immutableUser.update<string>(data.propertyId, x => x.toLowerCase() + ' Whirlwind');
 
     // updateIn: property path is strongly checked for up to 5 arguments (helps with refactoring and intellisense)
     // but will fall back to any[] if there are dynamic arguments on the way
-    const updatedUser5: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
+    const updatedUser51: Immutable.ImmutableObject<User> = immutableUserEx.updateIn([ 'address', 'line1' ], x => x.toLowerCase() + ' 43');
     // the type of the updated value must be explicity specified in case of fallback
-    const updatedUser6: Immutable.ImmutableObject<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
+    const updatedUser52: Immutable.ImmutableObject<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
 
     // without: the return type must be specified explicitly or it will be `any`
     const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');
diff --git a/types/seamless-immutable/tslint.json b/types/seamless-immutable/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/seamless-immutable/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }

From 7730d7619e34ae5b3362d1ba8b3501797c24ea13 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Mon, 10 Jul 2017 09:49:33 +0300
Subject: [PATCH 6/7] fix common mistakes

---
 types/seamless-immutable/index.d.ts                  | 12 +++++++-----
 types/seamless-immutable/seamless-immutable-tests.ts |  6 ++----
 2 files changed, 9 insertions(+), 9 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index d40c609dd4..70aa6b552d 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -37,6 +37,7 @@ declare namespace SeamlessImmutable {
     interface IImmutableObject<T> {
         set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
         set<TValue>(property: string, value: TValue): ImmutableObject<T>;
+
         setIn<K extends keyof T>
             (propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K]>
@@ -47,7 +48,7 @@ declare namespace SeamlessImmutable {
             (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
         setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
             (propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
-        setIn<TValue>(propertyPath: any[], value: TValue): ImmutableObject<T>;
+        setIn<TValue>(propertyPath: string[], value: TValue): ImmutableObject<T>;
 
         asMutable(): T;
         asMutable(opts: AsMutableOptions): T;
@@ -56,6 +57,7 @@ declare namespace SeamlessImmutable {
 
         update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         update<TValue>(property: string, updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+
         updateIn<K extends keyof T>
             (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K]>
@@ -66,11 +68,11 @@ declare namespace SeamlessImmutable {
             (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
             (propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<TValue>(propertyPath: any[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<TValue>(propertyPath: string[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
-        without<TTarget>(property: keyof T): ImmutableObject<TTarget>;
-        without<TTarget>(...properties: Array<keyof T>): ImmutableObject<TTarget>;
-        without<TTarget>(filter: (value: T[keyof T], key: keyof T) => boolean): ImmutableObject<TTarget>;
+        without(property: keyof T): ImmutableObject<T>;
+        without(...properties: Array<keyof T>): ImmutableObject<T>;
+        without(filter: (value: T[keyof T], key: keyof T) => boolean): ImmutableObject<T>;
     }
 
     interface IImmutableArray<T> {
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 64cbfdd6cb..4478ef80cd 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -109,8 +109,6 @@ interface ExtendedUser extends User {
     // the type of the updated value must be explicity specified in case of fallback
     const updatedUser52: Immutable.ImmutableObject<User> = immutableUserEx.updateIn<string>([ data.propertyId, 'line1' ], x => x.toLowerCase() + ' 43');
 
-    // without: the return type must be specified explicitly or it will be `any`
-    const simpleUser1: Immutable.ImmutableObject<any> = immutableUserEx.without('address');
-    const simpleUser2: Immutable.ImmutableObject<User> = immutableUserEx.without<User>('address');
-    const simpleUser3: Immutable.ImmutableObject<any> = immutableUserEx.without('firstName', 'lastName');
+    // without
+    const simpleUser1: Immutable.ImmutableObject<User> = immutableUserEx.without('address');
 }

From 4450b36336f984e89f79a97faab6e789cd21cbb0 Mon Sep 17 00:00:00 2001
From: Stepan Burguchev <me@sburg.net>
Date: Mon, 10 Jul 2017 10:30:45 +0300
Subject: [PATCH 7/7] add function-like constructor; fix lint errors

---
 types/seamless-immutable/index.d.ts           | 85 ++++++++-----------
 .../seamless-immutable-tests.ts               |  9 +-
 2 files changed, 44 insertions(+), 50 deletions(-)

diff --git a/types/seamless-immutable/index.d.ts b/types/seamless-immutable/index.d.ts
index 70aa6b552d..16256d8e83 100644
--- a/types/seamless-immutable/index.d.ts
+++ b/types/seamless-immutable/index.d.ts
@@ -1,19 +1,10 @@
-// Type definitions for Seamless-immutable 6.1.3
+// Type definitions for Seamless-immutable 7.1
 // Project: https://github.com/rtfeldman/seamless-immutable
 // Definitions by: alex3165 <https://github.com/alex3165>
 //                 Stepan Burguchev <https://github.com/xsburg>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 // TypeScript Version: 2.3
 
-// This project is licensed under the MIT license.
-// Copyrights are respective of each contributor listed at the beginning of each definition file.
-
-// Permission is hereby granted, free of charge, to any person obtaining a copy of this software and associated documentation files (the "Software"), to deal in the Software without restriction, including without limitation the rights to use, copy, modify, merge, publish, distribute, sublicense, and/or sell copies of the Software, and to permit persons to whom the Software is furnished to do so, subject to the following conditions:
-
-// The above copyright notice and this permission notice shall be included in all copies or substantial portions of the Software.
-
-// THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY, FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM, OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE SOFTWARE.
-
 export = SeamlessImmutable;
 
 declare namespace SeamlessImmutable {
@@ -23,7 +14,7 @@ declare namespace SeamlessImmutable {
 
     interface MergeConfig {
         deep?: boolean;
-        merger?: Function;
+        merger?(a: any, b: any, config: any): any;
     }
 
     interface Options {
@@ -34,61 +25,59 @@ declare namespace SeamlessImmutable {
         deep: boolean;
     }
 
-    interface IImmutableObject<T> {
+    interface ImmutableObjectMixin<T> {
         set<K extends keyof T>(property: K, value: T[K]): ImmutableObject<T>;
         set<TValue>(property: string, value: TValue): ImmutableObject<T>;
 
-        setIn<K extends keyof T>
-            (propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K]>
-            (propertyPath: [ K, L ], value: T[K][L]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
-            (propertyPath: [ K, L, M ], value: T[K][L][M]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
-            (propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
-        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
-            (propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
+        setIn<K extends keyof T>(propertyPath: [ K ], value: T[K]): ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K]>(propertyPath: [ K, L ], value: T[K][L]): ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(propertyPath: [ K, L, M ], value: T[K][L][M]): ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>(
+            propertyPath: [ K, L, M, N ], value: T[K][L][M][N]): ImmutableObject<T>;
+        setIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>(
+            propertyPath: [ K, L, M, N, O ], value: T[K][L][M][N][O]): ImmutableObject<T>;
         setIn<TValue>(propertyPath: string[], value: TValue): ImmutableObject<T>;
 
-        asMutable(): T;
-        asMutable(opts: AsMutableOptions): T;
+        asMutable(opts?: AsMutableOptions): T;
 
         merge(part: DeepPartial<T>, config?: MergeConfig): ImmutableObject<T>;
 
         update<K extends keyof T>(property: K, updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         update<TValue>(property: string, updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
-        updateIn<K extends keyof T>
-            (propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<K extends keyof T, L extends keyof T[K]>
-            (propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>
-            (propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>
-            (propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
-        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>
-            (propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T>(
+            propertyPath: [ K ], updaterFunction: (value: T[K], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K]>(
+            propertyPath: [ K, L ], updaterFunction: (value: T[K][L], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L]>(
+            propertyPath: [ K, L, M ], updaterFunction: (value: T[K][L][M], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M]>(
+            propertyPath: [ K, L, M, N ], updaterFunction: (value: T[K][L][M][N], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
+        updateIn<K extends keyof T, L extends keyof T[K], M extends keyof T[K][L], N extends keyof T[K][L][M], O extends keyof T[K][L][M][N]>(
+            propertyPath: [ K, L, M, N, O ], updaterFunction: (value: T[K][L][M][N][O], ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
         updateIn<TValue>(propertyPath: string[], updaterFunction: (value: TValue, ...additionalParameters: any[]) => any, ...additionalArguments: any[]): ImmutableObject<T>;
 
-        without(property: keyof T): ImmutableObject<T>;
-        without(...properties: Array<keyof T>): ImmutableObject<T>;
-        without(filter: (value: T[keyof T], key: keyof T) => boolean): ImmutableObject<T>;
+        without<K extends keyof T>(property: K): ImmutableObject<T>;
+        without<K extends keyof T>(...properties: K[]): ImmutableObject<T>;
+        without<K extends keyof T>(filter: (value: T[K], key: K) => boolean): ImmutableObject<T>;
     }
 
-    interface IImmutableArray<T> {
-        asMutable(): Array<T>;
-        asMutable(opts: AsMutableOptions): Array<T>;
+    interface ImmutableArrayMixin<T> {
+        asMutable(opts?: AsMutableOptions): T[];
         asObject(toKeyValue: (item: T) => [string, any]): ImmutableObject<any>;
-        flatMap<TTarget>(mapFunction: (item: T) => Array<TTarget>): ImmutableArray<TTarget>;
+        flatMap<TTarget>(mapFunction: (item: T) => TTarget[]): ImmutableArray<TTarget>;
     }
 
-    export type ImmutableObject<T> = T & IImmutableObject<T>;
-    export type ImmutableArray<T> = Array<T> & IImmutableArray<T>;
-    export type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
+    type ImmutableObject<T> = T & ImmutableObjectMixin<T>;
+    type ImmutableArray<T> = T[] & ImmutableArrayMixin<T>;
+    type Immutable<T> = ImmutableObject<T> | ImmutableArray<T>;
 
-    export function from<T>(obj: Array<T>, options?: Options): ImmutableArray<T>;
-    export function from<T>(obj: T, options?: Options): ImmutableObject<T>;
+    function from<T>(obj: T[], options?: Options): ImmutableArray<T>;
+    function from<T>(obj: T, options?: Options): ImmutableObject<T>;
 
-    export function isImmutable(target: any): boolean;
-    export function ImmutableError(message: string): Error;
+    function isImmutable(target: any): boolean;
+    function ImmutableError(message: string): Error;
 }
+
+declare function SeamlessImmutable<T>(obj: T[], options?: SeamlessImmutable.Options): SeamlessImmutable.ImmutableArray<T>;
+declare function SeamlessImmutable<T>(obj: T, options?: SeamlessImmutable.Options): SeamlessImmutable.ImmutableObject<T>;
diff --git a/types/seamless-immutable/seamless-immutable-tests.ts b/types/seamless-immutable/seamless-immutable-tests.ts
index 4478ef80cd..606d991aea 100644
--- a/types/seamless-immutable/seamless-immutable-tests.ts
+++ b/types/seamless-immutable/seamless-immutable-tests.ts
@@ -25,8 +25,13 @@ interface ExtendedUser extends User {
         lastName: string;
     }
 
-    const arrayOfNumbers: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
-    const user: Immutable.ImmutableObject<User> = Immutable.from({
+    const arrayOfNumbers1: Immutable.ImmutableArray<number> = Immutable.from([0, 2]);
+    const arrayOfNumbers2: Immutable.ImmutableArray<number> = Immutable([0, 2]);
+    const user1: Immutable.ImmutableObject<User> = Immutable.from({
+        firstName: 'Angry',
+        lastName: 'Monkey'
+    });
+    const user2: Immutable.ImmutableObject<User> = Immutable({
         firstName: 'Angry',
         lastName: 'Monkey'
     });