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] 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
+}