style(typings): remove *Signature interfaces (#1978)

This change removes the *Signature interfaces and moves them to the the
    methods themselves.  Using the new `this` syntax provided by TypeScript
    2.0.

    Requires TypeScript 2.0

src/add/operator/audit.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { audit, AuditSignature } from '../../operator/audit';
+import { audit } from '../../operator/audit';
 
 Observable.prototype.audit = audit;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    audit: AuditSignature<T>;
+    audit: typeof audit;
   }
 }

src/add/operator/auditTime.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { auditTime, AuditTimeSignature } from '../../operator/auditTime';
+import { auditTime } from '../../operator/auditTime';
 
 Observable.prototype.auditTime = auditTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    auditTime: AuditTimeSignature<T>;
+    auditTime: typeof auditTime;
   }
 }

src/add/operator/buffer.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { buffer, BufferSignature } from '../../operator/buffer';
+import { buffer } from '../../operator/buffer';
 
 Observable.prototype.buffer = buffer;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    buffer: BufferSignature<T>;
+    buffer: typeof buffer;
   }
 }

src/add/operator/bufferCount.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferCount, BufferCountSignature } from '../../operator/bufferCount';
+import { bufferCount } from '../../operator/bufferCount';
 
 Observable.prototype.bufferCount = bufferCount;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    bufferCount: BufferCountSignature<T>;
+    bufferCount: typeof bufferCount;
   }
 }

src/add/operator/bufferTime.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferTime, BufferTimeSignature } from '../../operator/bufferTime';
+import { bufferTime } from '../../operator/bufferTime';
 
 Observable.prototype.bufferTime = bufferTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    bufferTime: BufferTimeSignature<T>;
+    bufferTime: typeof bufferTime;
   }
 }

src/add/operator/bufferToggle.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferToggle, BufferToggleSignature } from '../../operator/bufferToggle';
+import { bufferToggle } from '../../operator/bufferToggle';
 
 Observable.prototype.bufferToggle = bufferToggle;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    bufferToggle: BufferToggleSignature<T>;
+    bufferToggle: typeof bufferToggle;
   }
 }

src/add/operator/bufferWhen.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { bufferWhen, BufferWhenSignature } from '../../operator/bufferWhen';
+import { bufferWhen } from '../../operator/bufferWhen';
 
 Observable.prototype.bufferWhen = bufferWhen;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    bufferWhen: BufferWhenSignature<T>;
+    bufferWhen: typeof bufferWhen;
   }
 }

src/add/operator/catch.ts

@@ -1,13 +1,13 @@
 
 import { Observable } from '../../Observable';
-import { _catch, CatchSignature } from '../../operator/catch';
+import { _catch } from '../../operator/catch';
 
 Observable.prototype.catch = _catch;
 Observable.prototype._catch = _catch;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    catch: CatchSignature<T>;
-    _catch: CatchSignature<T>;
+    catch: typeof _catch;
+    _catch: typeof _catch;
   }
 }

src/add/operator/combineAll.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { combineAll, CombineAllSignature } from '../../operator/combineAll';
+import { combineAll } from '../../operator/combineAll';
 
 Observable.prototype.combineAll = combineAll;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    combineAll: CombineAllSignature<T>;
+    combineAll: typeof combineAll;
   }
 }

src/add/operator/combineLatest.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { combineLatest, CombineLatestSignature } from '../../operator/combineLatest';
+import { combineLatest } from '../../operator/combineLatest';
 
 Observable.prototype.combineLatest = combineLatest;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    combineLatest: CombineLatestSignature<T>;
+    combineLatest: typeof combineLatest;
   }
 }

src/add/operator/concat.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concat, ConcatSignature } from '../../operator/concat';
+import { concat } from '../../operator/concat';
 
 Observable.prototype.concat = concat;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    concat: ConcatSignature<T>;
+    concat: typeof concat;
   }
 }

src/add/operator/concatAll.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatAll, ConcatAllSignature } from '../../operator/concatAll';
+import { concatAll } from '../../operator/concatAll';
 
 Observable.prototype.concatAll = concatAll;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    concatAll: ConcatAllSignature<T>;
+    concatAll: typeof concatAll;
   }
 }

src/add/operator/concatMap.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatMap, ConcatMapSignature } from '../../operator/concatMap';
+import { concatMap } from '../../operator/concatMap';
 
 Observable.prototype.concatMap = concatMap;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    concatMap: ConcatMapSignature<T>;
+    concatMap: typeof concatMap;
   }
 }

src/add/operator/concatMapTo.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { concatMapTo, ConcatMapToSignature } from '../../operator/concatMapTo';
+import { concatMapTo } from '../../operator/concatMapTo';
 
 Observable.prototype.concatMapTo = concatMapTo;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    concatMapTo: ConcatMapToSignature<T>;
+    concatMapTo: typeof concatMapTo;
   }
 }

src/add/operator/count.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { count, CountSignature } from '../../operator/count';
+import { count } from '../../operator/count';
 
 Observable.prototype.count = count;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    count: CountSignature<T>;
+    count: typeof count;
   }
 }

src/add/operator/debounce.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { debounce, DebounceSignature } from '../../operator/debounce';
+import { debounce } from '../../operator/debounce';
 
 Observable.prototype.debounce = debounce;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    debounce: DebounceSignature<T>;
+    debounce: typeof debounce;
   }
 }

src/add/operator/debounceTime.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { debounceTime, DebounceTimeSignature } from '../../operator/debounceTime';
+import { debounceTime } from '../../operator/debounceTime';
 
 Observable.prototype.debounceTime = debounceTime;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    debounceTime: DebounceTimeSignature<T>;
+    debounceTime: typeof debounceTime;
   }
 }

src/add/operator/defaultIfEmpty.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { defaultIfEmpty, DefaultIfEmptySignature } from '../../operator/defaultIfEmpty';
+import { defaultIfEmpty } from '../../operator/defaultIfEmpty';
 
 Observable.prototype.defaultIfEmpty = defaultIfEmpty;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    defaultIfEmpty: DefaultIfEmptySignature<T>;
+    defaultIfEmpty: typeof defaultIfEmpty;
   }
 }

src/add/operator/delay.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { delay, DelaySignature } from '../../operator/delay';
+import { delay } from '../../operator/delay';
 
 Observable.prototype.delay = delay;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    delay: DelaySignature<T>;
+    delay: typeof delay;
   }
 }

src/add/operator/delayWhen.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { delayWhen, DelayWhenSignature } from '../../operator/delayWhen';
+import { delayWhen } from '../../operator/delayWhen';
 
 Observable.prototype.delayWhen = delayWhen;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    delayWhen: DelayWhenSignature<T>;
+    delayWhen: typeof delayWhen;
   }
 }

src/add/operator/dematerialize.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { dematerialize, DematerializeSignature } from '../../operator/dematerialize';
+import { dematerialize } from '../../operator/dematerialize';
 
 Observable.prototype.dematerialize = dematerialize;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    dematerialize: DematerializeSignature<T>;
+    dematerialize: typeof dematerialize;
   }
 }

src/add/operator/distinct.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { distinct, DistinctSignature } from '../../operator/distinct';
+import { distinct } from '../../operator/distinct';
 
 Observable.prototype.distinct = distinct;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    distinct: DistinctSignature<T>;
+    distinct: typeof distinct;
   }
 }

src/add/operator/distinctKey.ts

@@ -1,10 +1,10 @@
 import { Observable } from '../../Observable';
-import { distinctKey, DistinctKeySignature } from '../../operator/distinctKey';
+import { distinctKey } from '../../operator/distinctKey';
 
 Observable.prototype.distinctKey = distinctKey;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    distinctKey: DistinctKeySignature<T>;
+    distinctKey: typeof distinctKey;
   }
 }

src/add/operator/distinctUntilChanged.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { distinctUntilChanged, DistinctUntilChangedSignature } from '../../operator/distinctUntilChanged';
+import { distinctUntilChanged } from '../../operator/distinctUntilChanged';
 
 Observable.prototype.distinctUntilChanged = distinctUntilChanged;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    distinctUntilChanged: DistinctUntilChangedSignature<T>;
+    distinctUntilChanged: typeof distinctUntilChanged;
   }
 }

src/add/operator/distinctUntilKeyChanged.ts

@@ -1,11 +1,11 @@
 
 import { Observable } from '../../Observable';
-import { distinctUntilKeyChanged, DistinctUntilKeyChangedSignature } from '../../operator/distinctUntilKeyChanged';
+import { distinctUntilKeyChanged } from '../../operator/distinctUntilKeyChanged';
 
 Observable.prototype.distinctUntilKeyChanged = distinctUntilKeyChanged;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    distinctUntilKeyChanged: DistinctUntilKeyChangedSignature<T>;
+    distinctUntilKeyChanged: typeof distinctUntilKeyChanged;
   }
 }

src/add/operator/do.ts

@@ -1,13 +1,13 @@
 
 import { Observable } from '../../Observable';
-import { _do, DoSignature } from '../../operator/do';
+import { _do } from '../../operator/do';
 
 Observable.prototype.do = _do;
 Observable.prototype._do = _do;
 
 declare module '../../Observable' {
   interface Observable<T> {
-    do: DoSignature<T>;
-    _do: DoSignature<T>;
+    do: typeof _do;
+    _do: typeof _do;
   }
 }