diff --git a/src/CoreOperators.ts b/src/CoreOperators.ts
index 53e51e3eba..ccdec5ba0a 100644
--- a/src/CoreOperators.ts
+++ b/src/CoreOperators.ts
@@ -1,9 +1,5 @@
 import {Observable} from './Observable';
 import {Scheduler} from './Scheduler';
-import {ConnectableObservable} from './observable/ConnectableObservable';
-import {Subject} from './Subject';
-import {GroupedObservable} from './operator/groupBy';
-import {Notification} from './Notification';
 
 import {CombineLatestSignature} from './operator/combineLatest';
 import {WithLatestFromSignature} from './operator/withLatestFrom';
@@ -18,6 +14,62 @@ import {WindowCountSignature} from './operator/windowCount';
 import {WindowTimeSignature} from './operator/windowTime';
 import {WindowToggleSignature} from './operator/windowToggle';
 import {WindowWhenSignature} from './operator/windowWhen';
+import {CacheSignature} from './operator/cache';
+import {CatchSignature} from './operator/catch';
+import {CountSignature} from './operator/count';
+import {DematerializeSignature} from './operator/dematerialize';
+import {DebounceSignature} from './operator/debounce';
+import {DebounceTimeSignature} from './operator/debounceTime';
+import {DefaultIfEmptySignature} from './operator/defaultIfEmpty';
+import {DelaySignature} from './operator/delay';
+import {DelayWhenSignature} from './operator/delayWhen';
+import {DistinctUntilChangedSignature} from './operator/distinctUntilChanged';
+import {DoSignature} from './operator/do';
+import {ExpandSignature} from './operator/expand';
+import {FilterSignature} from './operator/filter';
+import {FinallySignature} from './operator/finally';
+import {FirstSignature} from './operator/first';
+import {GroupBySignature} from './operator/groupBy';
+import {IgnoreElementsSignature} from './operator/ignoreElements';
+import {InspectSignature} from './operator/inspect';
+import {InspectTimeSignature} from './operator/inspectTime';
+import {LastSignature} from './operator/last';
+import {LetSignature} from './operator/let';
+import {EverySignature} from './operator/every';
+import {MaterializeSignature} from './operator/materialize';
+import {MulticastSignature} from './operator/multicast';
+import {ObserveOnSignature} from './operator/observeOn';
+import {PartitionSignature} from './operator/partition';
+import {PluckSignature} from './operator/pluck';
+import {PublishSignature} from './operator/publish';
+import {PublishBehaviorSignature} from './operator/publishBehavior';
+import {PublishReplaySignature} from './operator/publishReplay';
+import {PublishLastSignature} from './operator/publishLast';
+import {RaceSignature} from './operator/race';
+import {ReduceSignature} from './operator/reduce';
+import {RepeatSignature} from './operator/repeat';
+import {RetrySignature} from './operator/retry';
+import {RetryWhenSignature} from './operator/retryWhen';
+import {SampleSignature} from './operator/sample';
+import {SampleTimeSignature} from './operator/sampleTime';
+import {ScanSignature} from './operator/scan';
+import {ShareSignature} from './operator/share';
+import {SingleSignature} from './operator/single';
+import {SkipSignature} from './operator/skip';
+import {SkipUntilSignature} from './operator/skipUntil';
+import {SkipWhileSignature} from './operator/skipWhile';
+import {StartWithSignature} from './operator/startWith';
+import {SubscribeOnSignature} from './operator/subscribeOn';
+import {TakeSignature} from './operator/take';
+import {TakeLastSignature} from './operator/takeLast';
+import {TakeUntilSignature} from './operator/takeUntil';
+import {TakeWhileSignature} from './operator/takeWhile';
+import {ThrottleSignature} from './operator/throttle';
+import {ThrottleTimeSignature} from './operator/throttleTime';
+import {TimeoutSignature} from './operator/timeout';
+import {TimeoutWithSignature} from './operator/timeoutWith';
+import {ToArraySignature} from './operator/toArray';
+import {ToPromiseSignature} from './operator/toPromise';
 
 export interface CoreOperators<T> {
   buffer: BufferSignature<T>;
@@ -25,83 +77,83 @@ export interface CoreOperators<T> {
   bufferTime: BufferTimeSignature<T>;
   bufferToggle: BufferToggleSignature<T>;
   bufferWhen: BufferWhenSignature<T>;
-  catch?: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
-  combineAll?: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
+  cache: CacheSignature<T>;
+  catch: CatchSignature<T>;
+  combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
   combineLatest: CombineLatestSignature<T>;
   concat?: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
   concatAll?: () => Observable<T>;
   concatMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   concatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  count?: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
-  dematerialize?: () => Observable<any>;
-  debounce?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  debounceTime?: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
-  defaultIfEmpty?: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
-  delay?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  delayWhen?: (delayDurationSelector: (value: T) => Observable<any>, subscriptionDelay?: Observable<any>) => Observable<T>;
-  distinctUntilChanged?: (compare?: (x: T, y: T) => boolean) => Observable<T>;
-  do?: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
-  expand?: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
-  filter?: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
-  finally?: (finallySelector: () => void) => Observable<T>;
-  first?: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-              resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
+  count: CountSignature<T>;
+  dematerialize: DematerializeSignature<T>;
+  debounce: DebounceSignature<T>;
+  debounceTime: DebounceTimeSignature<T>;
+  defaultIfEmpty: DefaultIfEmptySignature<T>;
+  delay: DelaySignature<T>;
+  delayWhen: DelayWhenSignature<T>;
+  distinctUntilChanged: DistinctUntilChangedSignature<T>;
+  do: DoSignature<T>;
+  expand: ExpandSignature<T>;
+  filter: FilterSignature<T>;
+  finally: FinallySignature<T>;
+  first: FirstSignature<T>;
   flatMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
                 projectResult?: (x: T, y: any, ix: number, iy: number) => R,
                 concurrent?: number) => Observable<R>;
   flatMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  groupBy?: <K, R>(keySelector: (value: T) => string,
-                elementSelector?: (value: T) => R,
-                durationSelector?: (group: GroupedObservable<K, R>) => Observable<any>) => Observable<GroupedObservable<K, R>>;
-  ignoreElements?: () => Observable<T>;
-  inspect?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  inspectTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  last?: <R>(predicate?: (value: T, index: number) => boolean,
-             resultSelector?: (value: T, index: number) => R,
-             defaultValue?: any) => Observable<T> | Observable<R>;
-  every?: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
+  groupBy: GroupBySignature<T>;
+  ignoreElements: IgnoreElementsSignature<T>;
+  inspect: InspectSignature<T>;
+  inspectTime: InspectTimeSignature<T>;
+  last: LastSignature<T>;
+  let: LetSignature<T>;
+  letBind: LetSignature<T>;
+  every: EverySignature<T>;
   map?: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
   mapTo?: <R>(value: R) => Observable<R>;
-  materialize?: () => Observable<Notification<T>>;
+  materialize: MaterializeSignature<T>;
   merge?: (...observables: any[]) => Observable<any>;
   mergeAll?: (concurrent?: number) => Observable<T>;
   mergeMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
                  projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
   mergeMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  multicast?: (subjectOrSubjectFactory: Subject<T>|(() => Subject<T>)) => ConnectableObservable<T>;
-  observeOn?: (scheduler: Scheduler, delay?: number) => Observable<T>;
-  partition?: (predicate: (x: T) => boolean) => Observable<T>[];
-  publish?: () => ConnectableObservable<T>;
-  publishBehavior?: (value: any) => ConnectableObservable<T>;
-  publishReplay?: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => ConnectableObservable<T>;
-  publishLast?: () => ConnectableObservable<T>;
-  reduce?: <R>(project: (acc: R, x: T) => R, seed?: R) => Observable<R>;
-  repeat?: (count?: number) => Observable<T>;
-  retry?: (count?: number) => Observable<T>;
-  retryWhen?: (notifier: (errors: Observable<any>) => Observable<any>) => Observable<T>;
-  sample?: (notifier: Observable<any>) => Observable<T>;
-  sampleTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  scan?: <R>(project: (acc: R, x: T) => R, acc?: R) => Observable<R>;
-  share?: () => Observable<T>;
-  single?: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
-  skip?: (count: number) => Observable<T>;
-  skipUntil?: (notifier: Observable<any>) => Observable<T>;
-  skipWhile?: (predicate: (x: T, index: number) => boolean) => Observable<T>;
-  startWith?: (x: T) => Observable<T>;
-  subscribeOn?: (scheduler: Scheduler, delay?: number) => Observable<T>;
+  multicast: MulticastSignature<T>;
+  observeOn: ObserveOnSignature<T>;
+  partition: PartitionSignature<T>;
+  pluck: PluckSignature<T>;
+  publish: PublishSignature<T>;
+  publishBehavior: PublishBehaviorSignature<T>;
+  publishReplay: PublishReplaySignature<T>;
+  publishLast: PublishLastSignature<T>;
+  race: RaceSignature<T>;
+  reduce: ReduceSignature<T>;
+  repeat: RepeatSignature<T>;
+  retry: RetrySignature<T>;
+  retryWhen: RetryWhenSignature<T>;
+  sample: SampleSignature<T>;
+  sampleTime: SampleTimeSignature<T>;
+  scan: ScanSignature<T>;
+  share: ShareSignature<T>;
+  single: SingleSignature<T>;
+  skip: SkipSignature<T>;
+  skipUntil: SkipUntilSignature<T>;
+  skipWhile: SkipWhileSignature<T>;
+  startWith: StartWithSignature<T>;
+  subscribeOn: SubscribeOnSignature<T>;
   switch?: () => Observable<T>;
   switchMap?: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   switchMapTo?: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  take?: (count: number) => Observable<T>;
-  takeLast?: (count: number) => Observable<T>;
-  takeUntil?: (notifier: Observable<any>) => Observable<T>;
-  takeWhile?: (predicate: (value: T, index: number) => boolean) => Observable<T>;
-  throttle?: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  throttleTime?: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  timeout?: (due: number | Date, errorToSend?: any, scheduler?: Scheduler) => Observable<T>;
-  timeoutWith?: <R>(due: number | Date, withObservable: Observable<R>, scheduler?: Scheduler) => Observable<T> | Observable<R>;
-  toArray?: () => Observable<T[]>;
-  toPromise?: (PromiseCtor: typeof Promise) => Promise<T>;
+  take: TakeSignature<T>;
+  takeLast: TakeLastSignature<T>;
+  takeUntil: TakeUntilSignature<T>;
+  takeWhile: TakeWhileSignature<T>;
+  throttle: ThrottleSignature<T>;
+  throttleTime: ThrottleTimeSignature<T>;
+  timeout: TimeoutSignature<T>;
+  timeoutWith: TimeoutWithSignature<T>;
+  toArray: ToArraySignature<T>;
+  toPromise: ToPromiseSignature<T>;
   window: WindowSignature<T>;
   windowCount: WindowCountSignature<T>;
   windowTime: WindowTimeSignature<T>;
diff --git a/src/Observable.ts b/src/Observable.ts
index a31a6a4469..bab0c89886 100644
--- a/src/Observable.ts
+++ b/src/Observable.ts
@@ -6,10 +6,6 @@ import {Subscription} from './Subscription';
 import {root} from './util/root';
 import {CoreOperators} from './CoreOperators';
 import {SymbolShim} from './util/SymbolShim';
-import {GroupedObservable} from './operator/groupBy';
-import {ConnectableObservable} from './observable/ConnectableObservable';
-import {Subject} from './Subject';
-import {Notification} from './Notification';
 import {toSubscriber} from './util/toSubscriber';
 import {tryCatch} from './util/tryCatch';
 import {errorObject} from './util/errorObject';
@@ -50,6 +46,62 @@ import {WindowCountSignature} from './operator/windowCount';
 import {WindowTimeSignature} from './operator/windowTime';
 import {WindowToggleSignature} from './operator/windowToggle';
 import {WindowWhenSignature} from './operator/windowWhen';
+import {CacheSignature} from './operator/cache';
+import {CatchSignature} from './operator/catch';
+import {CountSignature} from './operator/count';
+import {DematerializeSignature} from './operator/dematerialize';
+import {DebounceSignature} from './operator/debounce';
+import {DebounceTimeSignature} from './operator/debounceTime';
+import {DefaultIfEmptySignature} from './operator/defaultIfEmpty';
+import {DelaySignature} from './operator/delay';
+import {DelayWhenSignature} from './operator/delayWhen';
+import {DistinctUntilChangedSignature} from './operator/distinctUntilChanged';
+import {DoSignature} from './operator/do';
+import {ExpandSignature} from './operator/expand';
+import {FilterSignature} from './operator/filter';
+import {FinallySignature} from './operator/finally';
+import {FirstSignature} from './operator/first';
+import {GroupBySignature} from './operator/groupBy';
+import {IgnoreElementsSignature} from './operator/ignoreElements';
+import {InspectSignature} from './operator/inspect';
+import {InspectTimeSignature} from './operator/inspectTime';
+import {LastSignature} from './operator/last';
+import {LetSignature} from './operator/let';
+import {EverySignature} from './operator/every';
+import {MaterializeSignature} from './operator/materialize';
+import {MulticastSignature} from './operator/multicast';
+import {ObserveOnSignature} from './operator/observeOn';
+import {PartitionSignature} from './operator/partition';
+import {PluckSignature} from './operator/pluck';
+import {PublishSignature} from './operator/publish';
+import {PublishBehaviorSignature} from './operator/publishBehavior';
+import {PublishReplaySignature} from './operator/publishReplay';
+import {PublishLastSignature} from './operator/publishLast';
+import {RaceSignature} from './operator/race';
+import {ReduceSignature} from './operator/reduce';
+import {RepeatSignature} from './operator/repeat';
+import {RetrySignature} from './operator/retry';
+import {RetryWhenSignature} from './operator/retryWhen';
+import {SampleSignature} from './operator/sample';
+import {SampleTimeSignature} from './operator/sampleTime';
+import {ScanSignature} from './operator/scan';
+import {ShareSignature} from './operator/share';
+import {SingleSignature} from './operator/single';
+import {SkipSignature} from './operator/skip';
+import {SkipUntilSignature} from './operator/skipUntil';
+import {SkipWhileSignature} from './operator/skipWhile';
+import {StartWithSignature} from './operator/startWith';
+import {SubscribeOnSignature} from './operator/subscribeOn';
+import {TakeSignature} from './operator/take';
+import {TakeLastSignature} from './operator/takeLast';
+import {TakeUntilSignature} from './operator/takeUntil';
+import {TakeWhileSignature} from './operator/takeWhile';
+import {ThrottleSignature} from './operator/throttle';
+import {ThrottleTimeSignature} from './operator/throttleTime';
+import {TimeoutSignature} from './operator/timeout';
+import {TimeoutWithSignature} from './operator/timeoutWith';
+import {ToArraySignature} from './operator/toArray';
+import {ToPromiseSignature} from './operator/toPromise';
 
 export type ObservableOrPromise<T> = Observable<T> | Promise<T>;
 export type ArrayOrIterator<T> = Iterator<T> | ArrayLike<T>;
@@ -210,89 +262,84 @@ export class Observable<T> implements CoreOperators<T>  {
   bufferTime: BufferTimeSignature<T>;
   bufferToggle: BufferToggleSignature<T>;
   bufferWhen: BufferWhenSignature<T>;
-  cache: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => Observable<T>;
-  catch: (selector: (err: any, source: Observable<T>, caught: Observable<any>) => Observable<any>) => Observable<T>;
+  cache: CacheSignature<T>;
+  catch: CatchSignature<T>;
   combineAll: <R>(project?: (...values: Array<any>) => R) => Observable<R>;
   combineLatest: CombineLatestSignature<T>;
   concat: <R>(...observables: (Observable<any> | Scheduler)[]) => Observable<R>;
   concatAll: () => Observable<any>;
   concatMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   concatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  count: (predicate?: (value: T, index: number, source: Observable<T>) => boolean) => Observable<number>;
-  dematerialize: () => Observable<any>;
-  debounce: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  debounceTime: <R>(dueTime: number, scheduler?: Scheduler) => Observable<R>;
-  defaultIfEmpty: <R>(defaultValue?: T | R) => Observable<T> | Observable<R>;
-  delay: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  delayWhen: (delayDurationSelector: (value: T) => Observable<any>, subscriptionDelay?: Observable<any>) => Observable<T>;
-  distinctUntilChanged: (compare?: (x: T, y: T) => boolean) => Observable<T>;
-  do: (next?: (x: T) => void, error?: (e: any) => void, complete?: () => void) => Observable<T>;
-  expand: <R>(project: (x: T, ix: number) => Observable<R>, concurrent: number, scheduler: Scheduler) => Observable<R>;
-  filter: (predicate: (x: T) => boolean, ix?: number, thisArg?: any) => Observable<T>;
-  finally: (finallySelector: () => void) => Observable<T>;
-  first: <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-             resultSelector?: (value: T, index: number) => R, defaultValue?: any) => Observable<T> | Observable<R>;
+  count: CountSignature<T>;
+  dematerialize: DematerializeSignature<T>;
+  debounce: DebounceSignature<T>;
+  debounceTime: DebounceTimeSignature<T>;
+  defaultIfEmpty: DefaultIfEmptySignature<T>;
+  delay: DelaySignature<T>;
+  delayWhen: DelayWhenSignature<T>;
+  distinctUntilChanged: DistinctUntilChangedSignature<T>;
+  do: DoSignature<T>;
+  expand: ExpandSignature<T>;
+  filter: FilterSignature<T>;
+  finally: FinallySignature<T>;
+  first: FirstSignature<T>;
   flatMap: <R>(project: ((x: T, ix: number) => Observable<any>),
                projectResult?: (x: T, y: any, ix: number, iy: number) => R,
                concurrent?: number) => Observable<R>;
   flatMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  groupBy: <K, R>(keySelector: (value: T) => K,
-               elementSelector?: (value: T) => R,
-               durationSelector?: (group: GroupedObservable<K, R>) => Observable<any>) => Observable<GroupedObservable<K, R>>;
-  ignoreElements: () => Observable<T>;
-  inspect: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  inspectTime: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  last: <R>(predicate?: (value: T, index: number) => boolean,
-            resultSelector?: (value: T, index: number) => R,
-            defaultValue?: any) => Observable<T> | Observable<R>;
-  let: <T, R>(func: (selector: Observable<T>) => Observable<R>) => Observable<R>;
-  letBind: <T, R>(func: (selector: Observable<T>) => Observable<R>) => Observable<R>;
-  every: (predicate: (value: T, index: number) => boolean, thisArg?: any) => Observable<T>;
+  groupBy: GroupBySignature<T>;
+  ignoreElements: IgnoreElementsSignature<T>;
+  inspect: InspectSignature<T>;
+  inspectTime: InspectTimeSignature<T>;
+  last: LastSignature<T>;
+  let: LetSignature<T>;
+  letBind: LetSignature<T>;
+  every: EverySignature<T>;
   map: <R>(project: (x: T, ix?: number) => R, thisArg?: any) => Observable<R>;
   mapTo: <R>(value: R) => Observable<R>;
-  materialize: () => Observable<Notification<T>>;
+  materialize: MaterializeSignature<T>;
   merge: (...observables: any[]) => Observable<any>;
   mergeAll: (concurrent?: any) => Observable<any>;
   mergeMap: <R>(project: ((x: T, ix: number) => Observable<any>),
                 projectResult?: (x: T, y: any, ix: number, iy: number) => R,
                 concurrent?: number) => Observable<R>;
   mergeMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R, concurrent?: number) => Observable<R>;
-  multicast: (subjectOrSubjectFactory: Subject<T>|(() => Subject<T>)) => ConnectableObservable<T>;
-  observeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
-  partition: (predicate: (x: T) => boolean) => Observable<T>[];
-  pluck: (...properties: string[]) => Observable<any>;
-  publish: () => ConnectableObservable<T>;
-  publishBehavior: (value: any) => ConnectableObservable<T>;
-  publishReplay: (bufferSize?: number, windowTime?: number, scheduler?: Scheduler) => ConnectableObservable<T>;
-  publishLast: () => ConnectableObservable<T>;
-  race: (...observables: Array<Observable<T>>) => Observable<T>;
-  reduce: <R>(project: (acc: R, x: T) => R, seed?: R) => Observable<R>;
-  repeat: (count?: number) => Observable<T>;
-  retry: (count?: number) => Observable<T>;
-  retryWhen: (notifier: (errors: Observable<any>) => Observable<any>) => Observable<T>;
-  sample: (notifier: Observable<any>) => Observable<T>;
-  sampleTime: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  scan: <R>(accumulator: (acc: R, x: T) => R, seed?: T | R) => Observable<R>;
-  share: () => Observable<T>;
-  single: (predicate?: (value: T, index: number) => boolean) => Observable<T>;
-  skip: (count: number) => Observable<T>;
-  skipUntil: (notifier: Observable<any>) => Observable<T>;
-  skipWhile: (predicate: (x: T, index: number) => boolean) => Observable<T>;
-  startWith: (x: T) => Observable<T>;
-  subscribeOn: (scheduler: Scheduler, delay?: number) => Observable<T>;
+  multicast: MulticastSignature<T>;
+  observeOn: ObserveOnSignature<T>;
+  partition: PartitionSignature<T>;
+  pluck: PluckSignature<T>;
+  publish: PublishSignature<T>;
+  publishBehavior: PublishBehaviorSignature<T>;
+  publishReplay: PublishReplaySignature<T>;
+  publishLast: PublishLastSignature<T>;
+  race: RaceSignature<T>;
+  reduce: ReduceSignature<T>;
+  repeat: RepeatSignature<T>;
+  retry: RetrySignature<T>;
+  retryWhen: RetryWhenSignature<T>;
+  sample: SampleSignature<T>;
+  sampleTime: SampleTimeSignature<T>;
+  scan: ScanSignature<T>;
+  share: ShareSignature<T>;
+  single: SingleSignature<T>;
+  skip: SkipSignature<T>;
+  skipUntil: SkipUntilSignature<T>;
+  skipWhile: SkipWhileSignature<T>;
+  startWith: StartWithSignature<T>;
+  subscribeOn: SubscribeOnSignature<T>;
   switch: <R>() => Observable<R>;
   switchMap: <R>(project: ((x: T, ix: number) => Observable<any>), projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
   switchMapTo: <R>(observable: Observable<any>, projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
-  take: (count: number) => Observable<T>;
-  takeLast: (count: number) => Observable<T>;
-  takeUntil: (notifier: Observable<any>) => Observable<T>;
-  takeWhile: (predicate: (value: T, index: number) => boolean) => Observable<T>;
-  throttle: (durationSelector: (value: T) => Observable<any> | Promise<any>) => Observable<T>;
-  throttleTime: (delay: number, scheduler?: Scheduler) => Observable<T>;
-  timeout: (due: number | Date, errorToSend?: any, scheduler?: Scheduler) => Observable<T>;
-  timeoutWith: <R>(due: number | Date, withObservable: Observable<R>, scheduler?: Scheduler) => Observable<T> | Observable<R>;
-  toArray: () => Observable<T[]>;
-  toPromise: (PromiseCtor?: typeof Promise) => Promise<T>;
+  take: TakeSignature<T>;
+  takeLast: TakeLastSignature<T>;
+  takeUntil: TakeUntilSignature<T>;
+  takeWhile: TakeWhileSignature<T>;
+  throttle: ThrottleSignature<T>;
+  throttleTime: ThrottleTimeSignature<T>;
+  timeout: TimeoutSignature<T>;
+  timeoutWith: TimeoutWithSignature<T>;
+  toArray: ToArraySignature<T>;
+  toPromise: ToPromiseSignature<T>;
   window: WindowSignature<T>;
   windowCount: WindowCountSignature<T>;
   windowTime: WindowTimeSignature<T>;
diff --git a/src/Rx.KitchenSink.ts b/src/Rx.KitchenSink.ts
index 99cfc51337..d1347dd93d 100644
--- a/src/Rx.KitchenSink.ts
+++ b/src/Rx.KitchenSink.ts
@@ -3,21 +3,32 @@ import {Subject} from './Subject';
 /* tslint:enable:no-unused-variable */
 import {Observable} from './Observable';
 import {CoreOperators} from './CoreOperators';
-import {Scheduler as IScheduler} from './Scheduler';
+import {IsEmptySignature} from './operator/isEmpty';
+import {ElementAtSignature} from './operator/elementAt';
+import {DistinctSignature} from './operator/distinct';
+import {DistinctKeySignature} from './operator/distinctKey';
+import {DistinctUntilKeyChangedSignature} from './operator/distinctUntilKeyChanged';
+import {FindSignature} from './operator/find';
+import {FindIndexSignature} from './operator/findIndex';
+import {MaxSignature} from './operator/max';
+import {MinSignature} from './operator/min';
+import {PairwiseSignature} from './operator/pairwise';
+import {TimeIntervalSignature} from './operator/timeInterval';
+import {MergeScanSignature} from './operator/mergeScan';
 
 export interface KitchenSinkOperators<T> extends CoreOperators<T> {
-  isEmpty?: () => Observable<boolean>;
-  elementAt?: (index: number, defaultValue?: any) => Observable<T>;
-  distinct?: (compare?: (x: T, y: T) => boolean, flushes?: Observable<any>) => Observable<T>;
-  distinctKey?: (key: string, compare?: (x: T, y: T) => boolean, flushes?: Observable<any>) => Observable<T>;
-  distinctUntilKeyChanged?: (key: string, compare?: (x: any, y: any) => boolean) => Observable<T>;
-  find?: (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<T>;
-  findIndex?: (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any) => Observable<number>;
-  max?: <T, R>(comparer?: (x: R, y: T) => R) => Observable<R>;
-  min?: <T, R>(comparer?: (x: R, y: T) => R) => Observable<R>;
-  pairwise?: <R>() => Observable<R>;
-  timeInterval?: <T>(scheduler?: IScheduler) => Observable<T>;
-  mergeScan?: <T, R>(project: (acc: R, x: T) => Observable<R>, seed: R, concurrent?: number) => Observable<R>;
+  isEmpty?: IsEmptySignature<T>;
+  elementAt?: ElementAtSignature<T>;
+  distinct?: DistinctSignature<T>;
+  distinctKey?: DistinctKeySignature<T>;
+  distinctUntilKeyChanged?: DistinctUntilKeyChangedSignature<T>;
+  find?: FindSignature<T>;
+  findIndex?: FindIndexSignature<T>;
+  max?: MaxSignature<T>;
+  min?: MinSignature<T>;
+  pairwise?: PairwiseSignature<T>;
+  timeInterval?: TimeIntervalSignature<T>;
+  mergeScan?: MergeScanSignature<T>;
   exhaust?: () => Observable<T>;
   exhaustMap?: <R>(project: ((x: T, ix: number) => Observable<any>),
                        projectResult?: (x: T, y: any, ix: number, iy: number) => R) => Observable<R>;
diff --git a/src/add/operator/first.ts b/src/add/operator/first.ts
index 6eac3e41da..366718c21c 100644
--- a/src/add/operator/first.ts
+++ b/src/add/operator/first.ts
@@ -2,6 +2,6 @@
 import {Observable} from '../../Observable';
 import {first} from '../../operator/first';
 
-Observable.prototype.first = first;
+Observable.prototype.first = <any>first;
 
 export var _void: void;
\ No newline at end of file
diff --git a/src/add/operator/groupBy.ts b/src/add/operator/groupBy.ts
index 47fa1073eb..edc1f2b5c4 100644
--- a/src/add/operator/groupBy.ts
+++ b/src/add/operator/groupBy.ts
@@ -2,6 +2,6 @@
 import {Observable} from '../../Observable';
 import {groupBy} from '../../operator/groupBy';
 
-Observable.prototype.groupBy = groupBy;
+Observable.prototype.groupBy = <any>groupBy;
 
 export var _void: void;
\ No newline at end of file
diff --git a/src/add/operator/last.ts b/src/add/operator/last.ts
index d02a7a39db..cea84f9cac 100644
--- a/src/add/operator/last.ts
+++ b/src/add/operator/last.ts
@@ -2,6 +2,6 @@
 import {Observable} from '../../Observable';
 import {last} from '../../operator/last';
 
-Observable.prototype.last = last;
+Observable.prototype.last = <any>last;
 
 export var _void: void;
\ No newline at end of file
diff --git a/src/observable/ArrayLikeObservable.ts b/src/observable/ArrayLikeObservable.ts
index 5717ec2c1a..926b849654 100644
--- a/src/observable/ArrayLikeObservable.ts
+++ b/src/observable/ArrayLikeObservable.ts
@@ -7,9 +7,9 @@ import {Subscription} from '../Subscription';
 
 export class ArrayLikeObservable<T> extends Observable<T> {
 
-  private mapFn: (x: any, y: number) => T;
+  private mapFn: (x: T, y: number) => T;
 
-  static create<T>(arrayLike: ArrayLike<T>, mapFn: (x: any, y: number) => T, thisArg: any, scheduler?: Scheduler): Observable<T> {
+  static create<T>(arrayLike: ArrayLike<T>, mapFn: (x: T, y: number) => T, thisArg: any, scheduler?: Scheduler): Observable<T> {
     const length = arrayLike.length;
     if (length === 0) {
       return new EmptyObservable<T>();
@@ -43,7 +43,7 @@ export class ArrayLikeObservable<T> extends Observable<T> {
   // value used if Array has one value and _isScalar
   private value: any;
 
-  constructor(private arrayLike: ArrayLike<T>, mapFn: (x: any, y: number) => T, thisArg: any, private scheduler?: Scheduler) {
+  constructor(private arrayLike: ArrayLike<T>, mapFn: (x: T, y: number) => T, thisArg: any, private scheduler?: Scheduler) {
     super();
     if (!mapFn && !scheduler && arrayLike.length === 1) {
       this._isScalar = true;
diff --git a/src/observable/FromObservable.ts b/src/observable/FromObservable.ts
index ef54497e6d..29b6f56d9e 100644
--- a/src/observable/FromObservable.ts
+++ b/src/observable/FromObservable.ts
@@ -9,23 +9,23 @@ import {ArrayLikeObservable} from './ArrayLikeObservable';
 
 import {Scheduler} from '../Scheduler';
 import {SymbolShim} from '../util/SymbolShim';
-import {Observable} from '../Observable';
+import {Observable, ObservableInput} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {ObserveOnSubscriber} from '../operator/observeOn';
 
 const isArrayLike = (<T>(x: any): x is ArrayLike<T> => x && typeof x.length === 'number');
 
 export class FromObservable<T> extends Observable<T> {
-  constructor(private ish: Observable<T> | Promise<T> | Iterator<T> | ArrayLike<T>, private scheduler: Scheduler) {
+  constructor(private ish: ObservableInput<T>, private scheduler: Scheduler) {
     super(null);
   }
 
-  static create<T>(ish: any, mapFnOrScheduler?: Scheduler | ((x: any, y: number) => T), thisArg?: any, lastScheduler?: Scheduler): Observable<T> {
+  static create<T>(ish: any, mapFnOrScheduler?: Scheduler | ((x: any, i: number) => T), thisArg?: any, lastScheduler?: Scheduler): Observable<T> {
     let scheduler: Scheduler = null;
-    let mapFn: (x: number, y: any) => T = null;
+    let mapFn: (x: any, i: number) => T = null;
     if (isFunction(mapFnOrScheduler)) {
       scheduler = lastScheduler || null;
-      mapFn = <(x: number, y: any) => T> mapFnOrScheduler;
+      mapFn = <(x: any, i: number) => T> mapFnOrScheduler;
     } else if (isScheduler(scheduler)) {
       scheduler = <Scheduler> mapFnOrScheduler;
     }
diff --git a/src/operator/cache.ts b/src/operator/cache.ts
index 9ef1a03cbf..8868c24135 100644
--- a/src/operator/cache.ts
+++ b/src/operator/cache.ts
@@ -7,4 +7,8 @@ export function cache<T>(bufferSize: number = Number.POSITIVE_INFINITY,
                          windowTime: number = Number.POSITIVE_INFINITY,
                          scheduler?: Scheduler): Observable<T> {
   return (<ConnectableObservable<any>>publishReplay.call(this, bufferSize, windowTime, scheduler)).refCount();
-}
\ No newline at end of file
+}
+
+export interface CacheSignature<T> {
+  (bufferSize?: number, windowTime?: number, scheduler?: Scheduler): Observable<T>;
+}
diff --git a/src/operator/catch.ts b/src/operator/catch.ts
index e54dd3b911..c51eb90605 100644
--- a/src/operator/catch.ts
+++ b/src/operator/catch.ts
@@ -16,6 +16,10 @@ export function _catch<T, R>(selector: (err: any, caught: Observable<T>) => Obse
   return (operator.caught = caught);
 }
 
+export interface CatchSignature<T> {
+  <R>(selector: (err: any, caught: Observable<T>) => Observable<R>): Observable<R>;
+}
+
 class CatchOperator<T, R> implements Operator<T, R> {
   caught: Observable<any>;
 
diff --git a/src/operator/count.ts b/src/operator/count.ts
index 12bba0ef19..7808549806 100644
--- a/src/operator/count.ts
+++ b/src/operator/count.ts
@@ -20,6 +20,10 @@ export function count<T>(predicate?: (value: T, index: number, source: Observabl
   return this.lift(new CountOperator(predicate, this));
 }
 
+export interface CountSignature<T> {
+  (predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<number>;
+}
+
 class CountOperator<T> implements Operator<T, number> {
   constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private source?: Observable<T>) {
diff --git a/src/operator/debounce.ts b/src/operator/debounce.ts
index 21ef20a97a..68209d9aab 100644
--- a/src/operator/debounce.ts
+++ b/src/operator/debounce.ts
@@ -1,5 +1,5 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
+import {Observable, ObservableOrPromise} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
 
@@ -17,12 +17,16 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @param {function} durationSelector function for computing the timeout duration for each item.
  * @returns {Observable} an Observable the same as source Observable, but drops items.
  */
-export function debounce<T>(durationSelector: (value: T) => Observable<number> | Promise<number>): Observable<T> {
+export function debounce<T>(durationSelector: (value: T) => ObservableOrPromise<number>): Observable<T> {
   return this.lift(new DebounceOperator(durationSelector));
 }
 
+export interface DebounceSignature<T> {
+  (durationSelector: (value: T) => ObservableOrPromise<number>): Observable<T>;
+}
+
 class DebounceOperator<T> implements Operator<T, T> {
-  constructor(private durationSelector: (value: T) => Observable<number> | Promise<number>) {
+  constructor(private durationSelector: (value: T) => ObservableOrPromise<number>) {
   }
 
   call(subscriber: Subscriber<T>): Subscriber<T> {
@@ -36,7 +40,7 @@ class DebounceSubscriber<T, R> extends OuterSubscriber<T, R> {
   private durationSubscription: Subscription = null;
 
   constructor(destination: Subscriber<R>,
-              private durationSelector: (value: T) => Observable<number> | Promise<number>) {
+              private durationSelector: (value: T) => ObservableOrPromise<number>) {
     super(destination);
   }
 
@@ -57,7 +61,7 @@ class DebounceSubscriber<T, R> extends OuterSubscriber<T, R> {
     this.destination.complete();
   }
 
-  private _tryNext(value: T, duration: Observable<number> | Promise<number>): void {
+  private _tryNext(value: T, duration: ObservableOrPromise<number>): void {
     let subscription = this.durationSubscription;
     this.value = value;
     this.hasValue = true;
diff --git a/src/operator/debounceTime.ts b/src/operator/debounceTime.ts
index 4d03447e61..e3201ea1c5 100644
--- a/src/operator/debounceTime.ts
+++ b/src/operator/debounceTime.ts
@@ -21,6 +21,10 @@ export function debounceTime<T>(dueTime: number, scheduler: Scheduler = asap): O
   return this.lift(new DebounceTimeOperator(dueTime, scheduler));
 }
 
+export interface DebounceTimeSignature<T> {
+  (dueTime: number, scheduler?: Scheduler): Observable<T>;
+}
+
 class DebounceTimeOperator<T> implements Operator<T, T> {
   constructor(private dueTime: number, private scheduler: Scheduler) {
   }
diff --git a/src/operator/defaultIfEmpty.ts b/src/operator/defaultIfEmpty.ts
index d64ef9a4dc..0390c702bd 100644
--- a/src/operator/defaultIfEmpty.ts
+++ b/src/operator/defaultIfEmpty.ts
@@ -11,6 +11,11 @@ export function defaultIfEmpty<T, R>(defaultValue: R = null): Observable<T | R>
   return this.lift(new DefaultIfEmptyOperator(defaultValue));
 }
 
+export interface DefaultIfEmptySignature<T> {
+  (defaultValue?: T): Observable<T>;
+  <R>(defaultValue?: R): Observable<T | R>;
+}
+
 class DefaultIfEmptyOperator<T, R> implements Operator<T, T | R> {
 
   constructor(private defaultValue: R) {
diff --git a/src/operator/delay.ts b/src/operator/delay.ts
index f462165ec3..bb710027f7 100644
--- a/src/operator/delay.ts
+++ b/src/operator/delay.ts
@@ -20,6 +20,10 @@ export function delay<T>(delay: number|Date,
   return this.lift(new DelayOperator(delayFor, scheduler));
 }
 
+export interface DelaySignature<T> {
+  (delay: number | Date, scheduler?: Scheduler): Observable<T>;
+}
+
 class DelayOperator<T> implements Operator<T, T> {
   constructor(private delay: number,
               private scheduler: Scheduler) {
diff --git a/src/operator/delayWhen.ts b/src/operator/delayWhen.ts
index 11ad54f79a..a4b2a5c050 100644
--- a/src/operator/delayWhen.ts
+++ b/src/operator/delayWhen.ts
@@ -14,7 +14,6 @@ import {subscribeToResult} from '../util/subscribeToResult';
  * @param {Observable} sequence indicating the delay for the subscription to the source.
  * @returns {Observable} an Observable that delays the emissions of the source Observable by the specified timeout or Date.
  */
-
 export function delayWhen<T>(delayDurationSelector: (value: T) => Observable<any>,
                              subscriptionDelay?: Observable<any>): Observable<T> {
   if (subscriptionDelay) {
@@ -24,6 +23,10 @@ export function delayWhen<T>(delayDurationSelector: (value: T) => Observable<any
   return this.lift(new DelayWhenOperator(delayDurationSelector));
 }
 
+export interface DelayWhenSignature<T> {
+  (delayDurationSelector: (value: T) => Observable<any>, subscriptionDelay?: Observable<any>): Observable<T>;
+}
+
 class DelayWhenOperator<T> implements Operator<T, T> {
   constructor(private delayDurationSelector: (value: T) => Observable<any>) {
   }
diff --git a/src/operator/dematerialize.ts b/src/operator/dematerialize.ts
index fab25f365b..e79cd3b783 100644
--- a/src/operator/dematerialize.ts
+++ b/src/operator/dematerialize.ts
@@ -11,6 +11,10 @@ export function dematerialize<T>(): Observable<any> {
   return this.lift(new DeMaterializeOperator());
 }
 
+export interface DematerializeSignature<T> {
+  <R>(): Observable<R>;
+}
+
 class DeMaterializeOperator<T extends Notification<any>, R> implements Operator<T, R> {
   call(subscriber: Subscriber<any>) {
     return new DeMaterializeSubscriber(subscriber);
diff --git a/src/operator/distinct.ts b/src/operator/distinct.ts
index 80255d8f64..3da23f9628 100644
--- a/src/operator/distinct.ts
+++ b/src/operator/distinct.ts
@@ -20,6 +20,10 @@ export function distinct<T>(compare?: (x: T, y: T) => boolean, flushes?: Observa
   return this.lift(new DistinctOperator(compare, flushes));
 }
 
+export interface DistinctSignature<T> {
+  (compare?: (x: T, y: T) => boolean, flushes?: Observable<any>): Observable<T>;
+}
+
 class DistinctOperator<T> implements Operator<T, T> {
   constructor(private compare: (x: T, y: T) => boolean, private flushes: Observable<any>) {
   }
@@ -29,7 +33,7 @@ class DistinctOperator<T> implements Operator<T, T> {
   }
 }
 
-export class DistinctSubscriber<T, R> extends OuterSubscriber<T, R> {
+export class DistinctSubscriber<T> extends OuterSubscriber<T, T> {
   private values: Array<T> = [];
 
   constructor(destination: Subscriber<T>, compare: (x: T, y: T) => boolean, flushes: Observable<any>) {
@@ -43,13 +47,13 @@ export class DistinctSubscriber<T, R> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: T,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, T>): void {
     this.values.length = 0;
   }
 
-  notifyError(error: any, innerSub: InnerSubscriber<T, R>): void {
+  notifyError(error: any, innerSub: InnerSubscriber<T, T>): void {
     this._error(error);
   }
 
diff --git a/src/operator/distinctKey.ts b/src/operator/distinctKey.ts
index de2962867d..24b1cfe5af 100644
--- a/src/operator/distinctKey.ts
+++ b/src/operator/distinctKey.ts
@@ -21,3 +21,8 @@ export function distinctKey<T>(key: string, compare?: (x: T, y: T) => boolean, f
     return x[key] === y[key];
   }, flushes);
 }
+
+export interface DistinctKeySignature<T> {
+  (key: string): Observable<T>;
+  <K>(key: string, compare: (x: K, y: K) => boolean, flushes?: Observable<any>): Observable<T>;
+}
diff --git a/src/operator/distinctUntilChanged.ts b/src/operator/distinctUntilChanged.ts
index 87536df10b..a6c88874a5 100644
--- a/src/operator/distinctUntilChanged.ts
+++ b/src/operator/distinctUntilChanged.ts
@@ -11,12 +11,15 @@ import {Observable} from '../Observable';
  * @param {function} [compare] optional comparison function called to test if an item is distinct from the previous item in the source.
  * @returns {Observable} an Observable that emits items from the source Observable with distinct values.
  */
-export function distinctUntilChanged<T>(compare?: (x: T, y: T) => boolean): Observable<T>;
-export function distinctUntilChanged<T, K>(compare: (x: K, y: K) => boolean, keySelector?: (x: T) => K): Observable<T>;
-export function distinctUntilChanged<T, K>(compare: (x: K, y: K) => boolean, keySelector?: (x: T) => K): Observable<T> {
+export function distinctUntilChanged<T, K>(compare?: (x: K, y: K) => boolean, keySelector?: (x: T) => K): Observable<T> {
   return this.lift(new DistinctUntilChangedOperator<T, K>(compare, keySelector));
 }
 
+export interface DistinctUntilChangedSignature<T> {
+ (compare?: (x: T, y: T) => boolean): Observable<T>;
+ <K>(compare: (x: K, y: K) => boolean, keySelector: (x: T) => K): Observable<T>;
+}
+
 class DistinctUntilChangedOperator<T, K> implements Operator<T, T> {
   constructor(private compare: (x: K, y: K) => boolean,
               private keySelector: (x: T) => K) {
diff --git a/src/operator/distinctUntilKeyChanged.ts b/src/operator/distinctUntilKeyChanged.ts
index f8e95d0d49..ccde3022e3 100644
--- a/src/operator/distinctUntilKeyChanged.ts
+++ b/src/operator/distinctUntilKeyChanged.ts
@@ -18,3 +18,8 @@ export function distinctUntilKeyChanged<T>(key: string, compare?: (x: T, y: T) =
     return x[key] === y[key];
   });
 }
+
+export interface DistinctUntilKeyChangedSignature<T> {
+  (key: string): Observable<T>;
+  <K>(key: string, compare: (x: K, y: K) => boolean): Observable<T>;
+}
\ No newline at end of file
diff --git a/src/operator/do.ts b/src/operator/do.ts
index f06a09c705..48cedd5095 100644
--- a/src/operator/do.ts
+++ b/src/operator/do.ts
@@ -18,6 +18,11 @@ export function _do<T>(nextOrObserver?: PartialObserver<T> | ((x: T) => void),
   return this.lift(new DoOperator(nextOrObserver, error, complete));
 }
 
+export interface DoSignature<T> {
+  (next: (x: T) => void, error?: (e: any) => void, complete?: () => void): Observable<T>;
+  (observer: PartialObserver<T>): Observable<T>;
+}
+
 class DoOperator<T> implements Operator<T, T> {
   constructor(private nextOrObserver?: PartialObserver<T> | ((x: T) => void),
               private error?: (e: any) => void,
diff --git a/src/operator/elementAt.ts b/src/operator/elementAt.ts
index 84a2968b50..ce5dba265a 100644
--- a/src/operator/elementAt.ts
+++ b/src/operator/elementAt.ts
@@ -14,6 +14,10 @@ export function elementAt<T>(index: number, defaultValue?: T): Observable<T> {
   return this.lift(new ElementAtOperator(index, defaultValue));
 }
 
+export interface ElementAtSignature<T> {
+  (index: number, defaultValue?: T): Observable<T>;
+}
+
 class ElementAtOperator<T> implements Operator<T, T> {
 
   constructor(private index: number, private defaultValue?: T) {
diff --git a/src/operator/every.ts b/src/operator/every.ts
index 7d28eee577..e074cf51e7 100644
--- a/src/operator/every.ts
+++ b/src/operator/every.ts
@@ -15,7 +15,11 @@ export function every<T>(predicate: (value: T, index: number, source: Observable
   return source.lift(new EveryOperator(predicate, thisArg, source));
 }
 
-class EveryOperator<T, R> implements Operator<T, boolean> {
+export interface EverySignature<T> {
+  (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<boolean>;
+}
+
+class EveryOperator<T> implements Operator<T, boolean> {
   constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,
               private thisArg?: any,
               private source?: Observable<T>) {
@@ -26,10 +30,10 @@ class EveryOperator<T, R> implements Operator<T, boolean> {
   }
 }
 
-class EverySubscriber<T, R> extends Subscriber<T> {
+class EverySubscriber<T> extends Subscriber<T> {
   private index: number = 0;
 
-  constructor(destination: Observer<R>,
+  constructor(destination: Observer<boolean>,
               private predicate: (value: T, index: number, source: Observable<T>) => boolean,
               private thisArg: any,
               private source?: Observable<T>) {
diff --git a/src/operator/expand.ts b/src/operator/expand.ts
index 1575f2c6fa..6d0bfe7084 100644
--- a/src/operator/expand.ts
+++ b/src/operator/expand.ts
@@ -25,6 +25,11 @@ export function expand<T, R>(project: (value: T, index: number) => Observable<R>
   return this.lift(new ExpandOperator(project, concurrent, scheduler));
 }
 
+export interface ExpandSignature<T> {
+  (project: (value: T, index: number) => Observable<T>, concurrent?: number, scheduler?: Scheduler): Observable<T>;
+  <R>(project: (value: T, index: number) => Observable<R>, concurrent?: number, scheduler?: Scheduler): Observable<R>;
+}
+
 export class ExpandOperator<T, R> implements Operator<T, R> {
   constructor(private project: (value: T, index: number) => Observable<R>,
               private concurrent: number,
diff --git a/src/operator/filter.ts b/src/operator/filter.ts
index 011a47cfb5..a1b3ff1bb2 100644
--- a/src/operator/filter.ts
+++ b/src/operator/filter.ts
@@ -15,6 +15,10 @@ export function filter<T>(select: (value: T, index: number) => boolean, thisArg?
   return this.lift(new FilterOperator(select, thisArg));
 }
 
+export interface FilterSignature<T> {
+  (select: (value: T, index: number) => boolean, thisArg?: any): Observable<T>;
+}
+
 class FilterOperator<T> implements Operator<T, T> {
   constructor(private select: (value: T, index: number) => boolean, private thisArg?: any) {
   }
diff --git a/src/operator/finally.ts b/src/operator/finally.ts
index 8d4ee5d04a..d27c5a6f19 100644
--- a/src/operator/finally.ts
+++ b/src/operator/finally.ts
@@ -13,6 +13,10 @@ export function _finally<T>(finallySelector: () => void): Observable<T> {
   return this.lift(new FinallyOperator(finallySelector));
 }
 
+export interface FinallySignature<T> {
+  <T>(finallySelector: () => void): Observable<T>;
+}
+
 class FinallyOperator<T> implements Operator<T, T> {
   constructor(private finallySelector: () => void) {
   }
diff --git a/src/operator/find.ts b/src/operator/find.ts
index 74f63f22bd..ab6a287652 100644
--- a/src/operator/find.ts
+++ b/src/operator/find.ts
@@ -15,6 +15,10 @@ export function find<T>(predicate: (value: T, index: number, source: Observable<
   return this.lift(new FindValueOperator(predicate, this, false, thisArg));
 }
 
+export interface FindSignature<T> {
+  (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<T>;
+}
+
 export class FindValueOperator<T> implements Operator<T, T> {
   constructor(private predicate: (value: T, index: number, source: Observable<T>) => boolean,
               private source: Observable<T>,
diff --git a/src/operator/findIndex.ts b/src/operator/findIndex.ts
index 653d75368f..89e8d8f36d 100644
--- a/src/operator/findIndex.ts
+++ b/src/operator/findIndex.ts
@@ -10,3 +10,7 @@ import {FindValueOperator} from './find';
 export function findIndex<T>(predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number> {
   return this.lift(new FindValueOperator(predicate, this, true, thisArg));
 }
+
+export interface FindIndexSignature<T> {
+  (predicate: (value: T, index: number, source: Observable<T>) => boolean, thisArg?: any): Observable<number>;
+}
diff --git a/src/operator/first.ts b/src/operator/first.ts
index c6553f9ba2..c3d424949c 100644
--- a/src/operator/first.ts
+++ b/src/operator/first.ts
@@ -11,10 +11,17 @@ import {EmptyError} from '../util/EmptyError';
  */
 export function first<T, R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean,
                             resultSelector?: (value: T, index: number) => R,
-                            defaultValue?: R): Observable<T> | Observable<R> {
+                            defaultValue?: R): Observable<T | R> {
   return this.lift(new FirstOperator(predicate, resultSelector, defaultValue, this));
 }
 
+export interface FirstSignature<T> {
+  (predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T>;
+  (predicate: (value: T, index: number, source: Observable<T>) => boolean, resultSelector: void, defaultValue?: T): Observable<T>;
+  <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R,
+      defaultValue?: R): Observable<R>;
+}
+
 class FirstOperator<T, R> implements Operator<T, R> {
   constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private resultSelector?: (value: T, index: number) => R,
diff --git a/src/operator/groupBy.ts b/src/operator/groupBy.ts
index 2c439be375..d2d710fbb8 100644
--- a/src/operator/groupBy.ts
+++ b/src/operator/groupBy.ts
@@ -24,6 +24,14 @@ export function groupBy<T, K, R>(keySelector: (value: T) => K,
   return this.lift(new GroupByOperator(this, keySelector, elementSelector, durationSelector));
 }
 
+/* tslint:disable:max-line-length */
+export interface GroupBySignature<T> {
+  <K>(keySelector: (value: T) => K): Observable<GroupedObservable<K, T>>;
+  <K>(keySelector: (value: T) => K, elementSelector: void, durationSelector: (grouped: GroupedObservable<K, T>) => Observable<any>): Observable<GroupedObservable<K, T>>;
+  <K, R>(keySelector: (value: T) => K, elementSelector?: (value: T) => R, durationSelector?: (grouped: GroupedObservable<K, R>) => Observable<any>): Observable<GroupedObservable<K, R>>;
+}
+/* tslint:enable:max-line-length */
+
 export interface RefCountSubscription {
   count: number;
   unsubscribe: () => void;
diff --git a/src/operator/ignoreElements.ts b/src/operator/ignoreElements.ts
index ef97ae061d..4daf83293c 100644
--- a/src/operator/ignoreElements.ts
+++ b/src/operator/ignoreElements.ts
@@ -15,6 +15,10 @@ export function ignoreElements<T>(): Observable<T> {
   return this.lift(new IgnoreElementsOperator());
 };
 
+export interface IgnoreElementsSignature<T> {
+  (): Observable<T>;
+}
+
 class IgnoreElementsOperator<T, R> implements Operator<T, R> {
   call(subscriber: Subscriber<R>): Subscriber<T> {
     return new IgnoreElementsSubscriber(subscriber);
diff --git a/src/operator/inspect.ts b/src/operator/inspect.ts
index acb0e8e951..e55a30c776 100644
--- a/src/operator/inspect.ts
+++ b/src/operator/inspect.ts
@@ -1,6 +1,6 @@
 import {Operator} from '../Operator';
 import {Subscriber} from '../Subscriber';
-import {Observable} from '../Observable';
+import {Observable, ObservableOrPromise} from '../Observable';
 import {Subscription} from '../Subscription';
 
 import {tryCatch} from '../util/tryCatch';
@@ -8,12 +8,16 @@ import {errorObject} from '../util/errorObject';
 import {OuterSubscriber} from '../OuterSubscriber';
 import {subscribeToResult} from '../util/subscribeToResult';
 
-export function inspect<T>(durationSelector: (value: T) => Observable<any> | Promise<any>): Observable<T> {
+export function inspect<T>(durationSelector: (value: T) => ObservableOrPromise<any>): Observable<T> {
   return this.lift(new InspectOperator(durationSelector));
 }
 
+export interface InspectSignature<T> {
+  (durationSelector: (value: T) => ObservableOrPromise<any>): Observable<T>;
+}
+
 class InspectOperator<T> implements Operator<T, T> {
-  constructor(private durationSelector: (value: T) => Observable<any> | Promise<any>) {
+  constructor(private durationSelector: (value: T) => ObservableOrPromise<any>) {
   }
 
   call(subscriber: Subscriber<T>): Subscriber<T> {
@@ -28,7 +32,7 @@ class InspectSubscriber<T, R> extends OuterSubscriber<T, R> {
   private throttled: Subscription;
 
   constructor(destination: Subscriber<T>,
-              private durationSelector: (value: T) => Observable<any> | Promise<any>) {
+              private durationSelector: (value: T) => ObservableOrPromise<any>) {
     super(destination);
   }
 
diff --git a/src/operator/inspectTime.ts b/src/operator/inspectTime.ts
index 8ffe536f32..7c23436bb8 100644
--- a/src/operator/inspectTime.ts
+++ b/src/operator/inspectTime.ts
@@ -9,6 +9,10 @@ export function inspectTime<T>(delay: number, scheduler: Scheduler = asap): Obse
   return this.lift(new InspectTimeOperator(delay, scheduler));
 }
 
+export interface InspectTimeSignature<T> {
+  (delay: number, scheduler?: Scheduler): Observable<T>;
+}
+
 class InspectTimeOperator<T> implements Operator<T, T> {
   constructor(private delay: number, private scheduler: Scheduler) {
   }
diff --git a/src/operator/isEmpty.ts b/src/operator/isEmpty.ts
index eb4b7fcc16..69f5560247 100644
--- a/src/operator/isEmpty.ts
+++ b/src/operator/isEmpty.ts
@@ -13,6 +13,10 @@ export function isEmpty(): Observable<boolean> {
   return this.lift(new IsEmptyOperator());
 }
 
+export interface IsEmptySignature<T> {
+  (): Observable<boolean>;
+}
+
 class IsEmptyOperator implements Operator<any, boolean> {
   call (observer: Subscriber<boolean>): Subscriber<any> {
     return new IsEmptySubscriber(observer);
diff --git a/src/operator/last.ts b/src/operator/last.ts
index 904ac5f27d..979b72f685 100644
--- a/src/operator/last.ts
+++ b/src/operator/last.ts
@@ -17,11 +17,18 @@ import {EmptyError} from '../util/EmptyError';
  * @throws - Throws if no items that match the predicate are emitted by the source Observable.
  */
 export function last<T, R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean,
-                           resultSelector?: (value: T, index: number) => R,
-                           defaultValue?: R): Observable<T> | Observable<R> {
+                           resultSelector?: (value: T, index: number) => R | void,
+                           defaultValue?: R): Observable<T | R> {
   return this.lift(new LastOperator(predicate, resultSelector, defaultValue, this));
 }
 
+export interface LastSignature<T> {
+  (predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T>;
+  (predicate: (value: T, index: number, source: Observable<T>) => boolean, resultSelector: void, defaultValue?: T): Observable<T>;
+  <R>(predicate?: (value: T, index: number, source: Observable<T>) => boolean, resultSelector?: (value: T, index: number) => R,
+      defaultValue?: R): Observable<R>;
+}
+
 class LastOperator<T, R> implements Operator<T, R> {
   constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private resultSelector?: (value: T, index: number) => R,
diff --git a/src/operator/let.ts b/src/operator/let.ts
index e97023c675..667c0d4202 100644
--- a/src/operator/let.ts
+++ b/src/operator/let.ts
@@ -3,3 +3,7 @@ import {Observable} from '../Observable';
 export function letProto<T, R>(func: (selector: Observable<T>) => Observable<R>): Observable<R> {
   return func(this);
 }
+
+export interface LetSignature<T> {
+  <R>(func: (selector: Observable<T>) => Observable<R>): Observable<R>;
+}
diff --git a/src/operator/materialize.ts b/src/operator/materialize.ts
index 3eac01bd62..1f0c50d5c8 100644
--- a/src/operator/materialize.ts
+++ b/src/operator/materialize.ts
@@ -18,6 +18,10 @@ export function materialize<T>(): Observable<Notification<T>> {
   return this.lift(new MaterializeOperator());
 }
 
+export interface MaterializeSignature<T> {
+  (): Observable<Notification<T>>;
+}
+
 class MaterializeOperator<T> implements Operator<T, Notification<T>> {
   call(subscriber: Subscriber<Notification<T>>): Subscriber<T> {
     return new MaterializeSubscriber(subscriber);
diff --git a/src/operator/max.ts b/src/operator/max.ts
index 0dd4f66051..977c61f7cd 100644
--- a/src/operator/max.ts
+++ b/src/operator/max.ts
@@ -11,9 +11,13 @@ import {ReduceOperator} from './reduce';
  * items.
  * @returns {Observable} an Observable that emits item with the largest number.
  */
-export function max<T>(comparer?: (value1: T, value2: T) => T): Observable<T> {
+export function max<T>(comparer?: (x: T, y: T) => T): Observable<T> {
   const max: typeof comparer = (typeof comparer === 'function')
     ? comparer
     : (x, y) => x > y ? x : y;
   return this.lift(new ReduceOperator(max));
 }
+
+export interface MaxSignature<T> {
+  (comparer?: (x: T, y: T) => T): Observable<T>;
+}
diff --git a/src/operator/mergeScan.ts b/src/operator/mergeScan.ts
index 5652b4c184..9c76f36860 100644
--- a/src/operator/mergeScan.ts
+++ b/src/operator/mergeScan.ts
@@ -14,6 +14,10 @@ export function mergeScan<T, R>(project: (acc: R, value: T) => Observable<R>,
   return this.lift(new MergeScanOperator(project, seed, concurrent));
 }
 
+export interface MergeScanSignature<T> {
+  <R>(project: (acc: R, value: T) => Observable<R>, seed: R, concurrent?: number): Observable<R>;
+}
+
 export class MergeScanOperator<T, R> implements Operator<T, R> {
   constructor(private project: (acc: R, value: T) => Observable<R>,
               private seed: R,
diff --git a/src/operator/min.ts b/src/operator/min.ts
index 0ee8b28a8a..a12142c2d8 100644
--- a/src/operator/min.ts
+++ b/src/operator/min.ts
@@ -10,9 +10,13 @@ import {ReduceOperator} from './reduce';
  * @param {Function} optional comparer function that it will use instead of its default to compare the value of two items.
  * @returns {Observable<R>} an Observable that emits item with the smallest number.
  */
-export function min<T>(comparer?: (value1: T, value2: T) => T): Observable<T> {
+export function min<T>(comparer?: (x: T, y: T) => T): Observable<T> {
   const min: typeof comparer = (typeof comparer === 'function')
     ? comparer
     : (x, y) => x < y ? x : y;
   return this.lift(new ReduceOperator(min));
 }
+
+export interface MinSignature<T> {
+  (comparer?: (x: T, y: T) => T): Observable<T>;
+}
diff --git a/src/operator/multicast.ts b/src/operator/multicast.ts
index f87f076914..1115f61b45 100644
--- a/src/operator/multicast.ts
+++ b/src/operator/multicast.ts
@@ -26,3 +26,9 @@ export function multicast<T>(subjectOrSubjectFactory: Subject<T> | (() => Subjec
   }
   return new ConnectableObservable(this, subjectFactory);
 }
+
+export type factoryOrValue<T> = T | (() => T);
+
+export interface MulticastSignature<T> {
+  (subjectOrSubjectFactory: factoryOrValue<Subject<T>>): ConnectableObservable<T>;
+}
diff --git a/src/operator/observeOn.ts b/src/operator/observeOn.ts
index aca666be84..df9bcf6e42 100644
--- a/src/operator/observeOn.ts
+++ b/src/operator/observeOn.ts
@@ -9,6 +9,10 @@ export function observeOn<T>(scheduler: Scheduler, delay: number = 0): Observabl
   return this.lift(new ObserveOnOperator(scheduler, delay));
 }
 
+export interface ObserveOnSignature<T> {
+  (scheduler: Scheduler, delay?: number): Observable<T>;
+}
+
 export class ObserveOnOperator<T> implements Operator<T, T> {
   constructor(private scheduler: Scheduler, private delay: number = 0) {
   }
diff --git a/src/operator/pairwise.ts b/src/operator/pairwise.ts
index 9dee25c2b7..9fd9a8bdbb 100644
--- a/src/operator/pairwise.ts
+++ b/src/operator/pairwise.ts
@@ -15,6 +15,10 @@ export function pairwise<T>(): Observable<[T, T]> {
   return this.lift(new PairwiseOperator());
 }
 
+export interface PairwiseSignature<T> {
+  (): Observable<[T, T]>;
+}
+
 class PairwiseOperator<T> implements Operator<T, [T, T]> {
   call(subscriber: Subscriber<[T, T]>): Subscriber<T> {
     return new PairwiseSubscriber(subscriber);
diff --git a/src/operator/partition.ts b/src/operator/partition.ts
index 000196116d..04b17eaf8d 100644
--- a/src/operator/partition.ts
+++ b/src/operator/partition.ts
@@ -8,3 +8,7 @@ export function partition<T>(predicate: (value: T) => boolean, thisArg?: any): [
     filter.call(this, not(predicate, thisArg))
   ];
 }
+
+export interface PartitionSignature<T> {
+  (predicate: (value: T) => boolean, thisArg?: any): [Observable<T>, Observable<T>];
+}
diff --git a/src/operator/pluck.ts b/src/operator/pluck.ts
index 71e6e257fc..019ff09a3d 100644
--- a/src/operator/pluck.ts
+++ b/src/operator/pluck.ts
@@ -9,7 +9,7 @@ import {map} from './map';
  * @param {...args} properties the nested properties to pluck
  * @returns {Observable} Returns a new Observable sequence of property values
  */
-export function pluck(...properties: string[]): Observable<any> {
+export function pluck<R>(...properties: string[]): Observable<R> {
   const length = properties.length;
   if (length === 0) {
     throw new Error('List of properties cannot be empty.');
@@ -17,6 +17,10 @@ export function pluck(...properties: string[]): Observable<any> {
   return map.call(this, plucker(properties, length));
 }
 
+export interface PluckSignature<T> {
+  <R>(...properties: string[]): Observable<R>;
+}
+
 function plucker(props: string[], length: number): (x: string) => any {
   const mapper = (x: string) => {
     let currentProp = x;
diff --git a/src/operator/publish.ts b/src/operator/publish.ts
index 29b3d059bd..08da9b5bc4 100644
--- a/src/operator/publish.ts
+++ b/src/operator/publish.ts
@@ -13,3 +13,7 @@ import {ConnectableObservable} from '../observable/ConnectableObservable';
 export function publish<T>(): ConnectableObservable<T> {
   return multicast.call(this, new Subject<T>());
 }
+
+export interface PublishSignature<T> {
+  (): ConnectableObservable<T>;
+}
diff --git a/src/operator/publishBehavior.ts b/src/operator/publishBehavior.ts
index 70030175f0..be2c034cef 100644
--- a/src/operator/publishBehavior.ts
+++ b/src/operator/publishBehavior.ts
@@ -5,3 +5,7 @@ import {ConnectableObservable} from '../observable/ConnectableObservable';
 export function publishBehavior<T>(value: T): ConnectableObservable<T> {
   return multicast.call(this, new BehaviorSubject<T>(value));
 }
+
+export interface PublishBehaviorSignature<T> {
+  (value: T): ConnectableObservable<T>;
+}
diff --git a/src/operator/publishLast.ts b/src/operator/publishLast.ts
index da6f8116c4..42c4a3caef 100644
--- a/src/operator/publishLast.ts
+++ b/src/operator/publishLast.ts
@@ -5,3 +5,7 @@ import {ConnectableObservable} from '../observable/ConnectableObservable';
 export function publishLast<T>(): ConnectableObservable<T> {
   return multicast.call(this, new AsyncSubject<T>());
 }
+
+export interface PublishLastSignature<T> {
+  (): ConnectableObservable<T>;
+}
diff --git a/src/operator/publishReplay.ts b/src/operator/publishReplay.ts
index 556c7539d5..4248b36011 100644
--- a/src/operator/publishReplay.ts
+++ b/src/operator/publishReplay.ts
@@ -8,3 +8,7 @@ export function publishReplay<T>(bufferSize: number = Number.POSITIVE_INFINITY,
                                  scheduler?: Scheduler): ConnectableObservable<T> {
   return multicast.call(this, new ReplaySubject<T>(bufferSize, windowTime, scheduler));
 }
+
+export interface PublishReplaySignature<T> {
+  (bufferSize?: number, windowTime?: number, scheduler?: Scheduler): ConnectableObservable<T>;
+}
diff --git a/src/operator/race.ts b/src/operator/race.ts
index f50b5ce65c..92175c0b46 100644
--- a/src/operator/race.ts
+++ b/src/operator/race.ts
@@ -25,19 +25,25 @@ export function race<T>(...observables: Array<Observable<T> | Array<Observable<T
   return raceStatic.apply(this, observables);
 }
 
+export interface RaceSignature<T> {
+  (...observables: Array<Observable<T> | Array<Observable<T>>>): Observable<T>;
+  <R>(...observables: Array<Observable<any> | Array<Observable<T>>>): Observable<R>;
+}
+
 /**
  * Returns an Observable that mirrors the first source Observable to emit an item.
  * @param {...Observables} ...observables sources used to race for which Observable emits first.
  * @returns {Observable} an Observable that mirrors the output of the first Observable to emit an item.
  */
-export function raceStatic<T>(...observables: Array<Observable<T> | Array<Observable<T>>>): Observable<T> {
+export function raceStatic<T>(...observables: Array<Observable<T> | Array<Observable<T>>>): Observable<T>;
+export function raceStatic<R>(...observables: Array<Observable<any> | Array<Observable<any>>>): Observable<R> {
   // if the only argument is an array, it was most likely called with
   // `pair([obs1, obs2, ...])`
   if (observables.length === 1) {
     if (isArray(observables[0])) {
       observables = <Array<Observable<any>>>observables[0];
     } else {
-      return <Observable<T>>observables[0];
+      return <Observable<any>>observables[0];
     }
   }
 
@@ -50,7 +56,7 @@ export class RaceOperator<T> implements Operator<T, T> {
   }
 }
 
-export class RaceSubscriber<T, R> extends OuterSubscriber<T, R> {
+export class RaceSubscriber<T> extends OuterSubscriber<T, T> {
   private hasFirst: boolean = false;
   private observables: Observable<any>[] = [];
   private subscriptions: Subscription[] = [];
@@ -80,9 +86,9 @@ export class RaceSubscriber<T, R> extends OuterSubscriber<T, R> {
     }
   }
 
-  notifyNext(outerValue: T, innerValue: R,
+  notifyNext(outerValue: T, innerValue: T,
              outerIndex: number, innerIndex: number,
-             innerSub: InnerSubscriber<T, R>): void {
+             innerSub: InnerSubscriber<T, T>): void {
     if (!this.hasFirst) {
       this.hasFirst = true;
 
diff --git a/src/operator/reduce.ts b/src/operator/reduce.ts
index 91bf910dd5..8689c6eeda 100644
--- a/src/operator/reduce.ts
+++ b/src/operator/reduce.ts
@@ -22,6 +22,10 @@ export function reduce<T, R>(project: (acc: R, value: T) => R, seed?: R): Observ
   return this.lift(new ReduceOperator(project, seed));
 }
 
+export interface ReduceSignature<T> {
+  <R>(project: (acc: R, value: T) => R, seed?: R): Observable<R>;
+}
+
 export class ReduceOperator<T, R> implements Operator<T, R> {
 
   constructor(private project: (acc: R, value: T) => R, private seed?: R) {
diff --git a/src/operator/repeat.ts b/src/operator/repeat.ts
index 102bb4004e..4944e31705 100644
--- a/src/operator/repeat.ts
+++ b/src/operator/repeat.ts
@@ -25,6 +25,10 @@ export function repeat<T>(count: number = -1): Observable<T> {
   }
 }
 
+export interface RepeatSignature<T> {
+  (count?: number): Observable<T>;
+}
+
 class RepeatOperator<T> implements Operator<T, T> {
   constructor(private count: number,
               private source: Observable<T>) {
diff --git a/src/operator/retry.ts b/src/operator/retry.ts
index 74b7ef3db2..3174a46969 100644
--- a/src/operator/retry.ts
+++ b/src/operator/retry.ts
@@ -21,6 +21,10 @@ export function retry<T>(count: number = -1): Observable<T> {
   return this.lift(new RetryOperator(count, this));
 }
 
+export interface RetrySignature<T> {
+  (count?: number): Observable<T>;
+}
+
 class RetryOperator<T> implements Operator<T, T> {
   constructor(private count: number,
               private source: Observable<T>) {
diff --git a/src/operator/retryWhen.ts b/src/operator/retryWhen.ts
index 3d08c70ea3..8756037ea1 100644
--- a/src/operator/retryWhen.ts
+++ b/src/operator/retryWhen.ts
@@ -28,6 +28,10 @@ export function retryWhen<T>(notifier: (errors: Observable<any>) => Observable<a
   return this.lift(new RetryWhenOperator(notifier, this));
 }
 
+export interface RetryWhenSignature<T> {
+  (notifier: (errors: Observable<any>) => Observable<any>): Observable<T>;
+}
+
 class RetryWhenOperator<T> implements Operator<T, T> {
   constructor(protected notifier: (errors: Observable<any>) => Observable<any>,
               protected source: Observable<T>) {
diff --git a/src/operator/sample.ts b/src/operator/sample.ts
index 907599c8fd..c7e31eb22f 100644
--- a/src/operator/sample.ts
+++ b/src/operator/sample.ts
@@ -21,6 +21,10 @@ export function sample<T>(notifier: Observable<any>): Observable<T> {
   return this.lift(new SampleOperator(notifier));
 }
 
+export interface SampleSignature<T> {
+  (notifier: Observable<any>): Observable<T>;
+}
+
 class SampleOperator<T> implements Operator<T, T> {
   constructor(private notifier: Observable<any>) {
   }
diff --git a/src/operator/sampleTime.ts b/src/operator/sampleTime.ts
index ec881dc76a..a52a41d788 100644
--- a/src/operator/sampleTime.ts
+++ b/src/operator/sampleTime.ts
@@ -8,6 +8,10 @@ export function sampleTime<T>(delay: number, scheduler: Scheduler = asap): Obser
   return this.lift(new SampleTimeOperator(delay, scheduler));
 }
 
+export interface SampleTimeSignature<T> {
+  (delay: number, scheduler?: Scheduler): Observable<T>;
+}
+
 class SampleTimeOperator<T> implements Operator<T, T> {
   constructor(private delay: number, private scheduler: Scheduler) {
   }
diff --git a/src/operator/scan.ts b/src/operator/scan.ts
index 1841e83cf7..fffe02e5fe 100644
--- a/src/operator/scan.ts
+++ b/src/operator/scan.ts
@@ -13,12 +13,16 @@ import {Subscriber} from '../Subscriber';
  * @param {any} [seed] The initial accumulator value.
  * @returns {Obervable} An observable of the accumulated values.
  */
-export function scan<T, R>(accumulator: (acc: R, x: T) => R, seed?: T | R): Observable<R> {
+export function scan<T, R>(accumulator: (acc: R, value: T) => R, seed?: T | R): Observable<R> {
   return this.lift(new ScanOperator(accumulator, seed));
 }
 
+export interface ScanSignature<T> {
+  <R>(accumulator: (acc: R, value: T) => R, seed?: T | R): Observable<R>;
+}
+
 class ScanOperator<T, R> implements Operator<T, R> {
-  constructor(private accumulator: (acc: R, x: T) => R, private seed?: T | R) {
+  constructor(private accumulator: (acc: R, value: T) => R, private seed?: T | R) {
   }
 
   call(subscriber: Subscriber<R>): Subscriber<T> {
@@ -40,7 +44,7 @@ class ScanSubscriber<T, R> extends Subscriber<T> {
 
   private accumulatorSet: boolean = false;
 
-  constructor(destination: Subscriber<R>, private accumulator: (acc: R, x: T) => R, seed?: T|R) {
+  constructor(destination: Subscriber<R>, private accumulator: (acc: R, value: T) => R, seed?: T|R) {
     super(destination);
     this.seed = seed;
     this.accumulator = accumulator;
diff --git a/src/operator/share.ts b/src/operator/share.ts
index e2cb8574ff..4e99505459 100644
--- a/src/operator/share.ts
+++ b/src/operator/share.ts
@@ -19,3 +19,7 @@ function shareSubjectFactory() {
 export function share<T>(): Observable<T> {
   return multicast.call(this, shareSubjectFactory).refCount();
 };
+
+export interface ShareSignature<T> {
+  (): Observable<T>;
+}
diff --git a/src/operator/single.ts b/src/operator/single.ts
index 6e414e8d2e..f2a56ed3ab 100644
--- a/src/operator/single.ts
+++ b/src/operator/single.ts
@@ -20,6 +20,10 @@ export function single<T>(predicate?: (value: T, index: number, source: Observab
   return this.lift(new SingleOperator(predicate, this));
 }
 
+export interface SingleSignature<T> {
+  (predicate?: (value: T, index: number, source: Observable<T>) => boolean): Observable<T>;
+}
+
 class SingleOperator<T> implements Operator<T, T> {
   constructor(private predicate?: (value: T, index: number, source: Observable<T>) => boolean,
               private source?: Observable<T>) {
diff --git a/src/operator/skip.ts b/src/operator/skip.ts
index 00a977e5e8..282052783e 100644
--- a/src/operator/skip.ts
+++ b/src/operator/skip.ts
@@ -15,6 +15,10 @@ export function skip<T>(total: number): Observable<T> {
   return this.lift(new SkipOperator(total));
 }
 
+export interface SkipSignature<T> {
+  (total: number): Observable<T>;
+}
+
 class SkipOperator<T> implements Operator<T, T> {
   constructor(private total: number) {
   }
diff --git a/src/operator/skipUntil.ts b/src/operator/skipUntil.ts
index 9844156c72..ed26105834 100644
--- a/src/operator/skipUntil.ts
+++ b/src/operator/skipUntil.ts
@@ -20,6 +20,10 @@ export function skipUntil<T>(notifier: Observable<any>): Observable<T> {
   return this.lift(new SkipUntilOperator(notifier));
 }
 
+export interface SkipUntilSignature<T> {
+  (notifier: Observable<any>): Observable<T>;
+}
+
 class SkipUntilOperator<T> implements Operator<T, T> {
   constructor(private notifier: Observable<any>) {
   }
diff --git a/src/operator/skipWhile.ts b/src/operator/skipWhile.ts
index 1637ce8c6b..02e3ab1f3b 100644
--- a/src/operator/skipWhile.ts
+++ b/src/operator/skipWhile.ts
@@ -16,6 +16,10 @@ export function skipWhile<T>(predicate: (value: T, index: number) => boolean): O
   return this.lift(new SkipWhileOperator(predicate));
 }
 
+export interface SkipWhileSignature<T> {
+  (predicate: (value: T, index: number) => boolean): Observable<T>;
+}
+
 class SkipWhileOperator<T> implements Operator<T, T> {
   constructor(private predicate: (value: T, index: number) => boolean) {
   }
diff --git a/src/operator/startWith.ts b/src/operator/startWith.ts
index 2d4b699d3d..1597aa0fe6 100644
--- a/src/operator/startWith.ts
+++ b/src/operator/startWith.ts
@@ -33,3 +33,13 @@ export function startWith<T>(...array: Array<T | Scheduler>): Observable<T> {
     return concatStatic(new EmptyObservable<T>(scheduler), <Observable<T>>this);
   }
 }
+
+export interface StartWithSignature<T> {
+  (v1: T, scheduler?: Scheduler): Observable<T>;
+  (v1: T, v2: T, scheduler?: Scheduler): Observable<T>;
+  (v1: T, v2: T, v3: T, scheduler?: Scheduler): Observable<T>;
+  (v1: T, v2: T, v3: T, v4: T, scheduler?: Scheduler): Observable<T>;
+  (v1: T, v2: T, v3: T, v4: T, v5: T, scheduler?: Scheduler): Observable<T>;
+  (v1: T, v2: T, v3: T, v4: T, v5: T, v6: T, scheduler?: Scheduler): Observable<T>;
+  (...array: Array<T | Scheduler>): Observable<T>;
+}
diff --git a/src/operator/subscribeOn.ts b/src/operator/subscribeOn.ts
index 72839d0c52..ec1feddc69 100644
--- a/src/operator/subscribeOn.ts
+++ b/src/operator/subscribeOn.ts
@@ -14,3 +14,7 @@ import {SubscribeOnObservable} from '../observable/SubscribeOnObservable';
 export function subscribeOn<T>(scheduler: Scheduler, delay: number = 0): Observable<T> {
   return new SubscribeOnObservable<T>(this, delay, scheduler);
 }
+
+export interface SubscribeOnSignature<T> {
+  (scheduler: Scheduler, delay?: number): Observable<T>;
+}
\ No newline at end of file
diff --git a/src/operator/take.ts b/src/operator/take.ts
index 87ada04e65..7cdbe18d45 100644
--- a/src/operator/take.ts
+++ b/src/operator/take.ts
@@ -12,6 +12,10 @@ export function take<T>(total: number): Observable<T> {
   }
 }
 
+export interface TakeSignature<T> {
+  (total: number): Observable<T>;
+}
+
 class TakeOperator<T> implements Operator<T, T> {
   constructor(private total: number) {
     if (this.total < 0) {
diff --git a/src/operator/takeLast.ts b/src/operator/takeLast.ts
index 1c5504d32e..5246adc01d 100644
--- a/src/operator/takeLast.ts
+++ b/src/operator/takeLast.ts
@@ -12,6 +12,10 @@ export function takeLast<T>(total: number): Observable<T> {
   }
 }
 
+export interface TakeLastSignature<T> {
+  (total: number): Observable<T>;
+}
+
 class TakeLastOperator<T> implements Operator<T, T> {
   constructor(private total: number) {
     if (this.total < 0) {
diff --git a/src/operator/takeUntil.ts b/src/operator/takeUntil.ts
index 030935f9c0..1268ca6fb3 100644
--- a/src/operator/takeUntil.ts
+++ b/src/operator/takeUntil.ts
@@ -10,6 +10,10 @@ export function takeUntil<T>(notifier: Observable<any>): Observable<T> {
   return this.lift(new TakeUntilOperator(notifier));
 }
 
+export interface TakeUntilSignature<T> {
+  (notifier: Observable<any>): Observable<T>;
+}
+
 class TakeUntilOperator<T> implements Operator<T, T> {
   constructor(private notifier: Observable<any>) {
   }
diff --git a/src/operator/takeWhile.ts b/src/operator/takeWhile.ts
index c056ee9c41..7c26b76fdc 100644
--- a/src/operator/takeWhile.ts
+++ b/src/operator/takeWhile.ts
@@ -6,6 +6,10 @@ export function takeWhile<T>(predicate: (value: T, index: number) => boolean): O
   return this.lift(new TakeWhileOperator(predicate));
 }
 
+export interface TakeWhileSignature<T> {
+  (predicate: (value: T, index: number) => boolean): Observable<T>;
+}
+
 class TakeWhileOperator<T> implements Operator<T, T> {
   constructor(private predicate: (value: T, index: number) => boolean) {
   }
diff --git a/src/operator/throttle.ts b/src/operator/throttle.ts
index fd2ab80a2d..97b85fc40b 100644
--- a/src/operator/throttle.ts
+++ b/src/operator/throttle.ts
@@ -1,5 +1,5 @@
 import {Operator} from '../Operator';
-import {Observable} from '../Observable';
+import {Observable, ObservableOrPromise} from '../Observable';
 import {Subscriber} from '../Subscriber';
 import {Subscription} from '../Subscription';
 
@@ -7,12 +7,16 @@ import {OuterSubscriber} from '../OuterSubscriber';
 import {InnerSubscriber} from '../InnerSubscriber';
 import {subscribeToResult} from '../util/subscribeToResult';
 
-export function throttle<T>(durationSelector: (value: T) => Observable<number> | Promise<number>): Observable<T> {
+export function throttle<T>(durationSelector: (value: T) => ObservableOrPromise<number>): Observable<T> {
   return this.lift(new ThrottleOperator(durationSelector));
 }
 
+export interface ThrottleSignature<T> {
+  (durationSelector: (value: T) => ObservableOrPromise<number>): Observable<T>;
+}
+
 class ThrottleOperator<T> implements Operator<T, T> {
-  constructor(private durationSelector: (value: T) => Observable<number> | Promise<number>) {
+  constructor(private durationSelector: (value: T) => ObservableOrPromise<number>) {
   }
 
   call(subscriber: Subscriber<T>): Subscriber<T> {
@@ -24,7 +28,7 @@ class ThrottleSubscriber<T, R> extends OuterSubscriber<T, R> {
   private throttled: Subscription;
 
   constructor(protected destination: Subscriber<T>,
-              private durationSelector: (value: T) => Observable<number> | Promise<number>) {
+              private durationSelector: (value: T) => ObservableOrPromise<number>) {
     super(destination);
   }
 
@@ -35,7 +39,7 @@ class ThrottleSubscriber<T, R> extends OuterSubscriber<T, R> {
   }
 
   private tryDurationSelector(value: T): void {
-    let duration: Observable<number> | Promise<number> = null;
+    let duration: ObservableOrPromise<number> = null;
     try {
       duration = this.durationSelector(value);
     } catch (err) {
@@ -45,7 +49,7 @@ class ThrottleSubscriber<T, R> extends OuterSubscriber<T, R> {
     this.emitAndThrottle(value, duration);
   }
 
-  private emitAndThrottle(value: T, duration: Observable<number> | Promise<number>) {
+  private emitAndThrottle(value: T, duration: ObservableOrPromise<number>) {
     this.add(this.throttled = subscribeToResult(this, duration));
     this.destination.next(value);
   }
diff --git a/src/operator/throttleTime.ts b/src/operator/throttleTime.ts
index 217743da4c..3f62a463b9 100644
--- a/src/operator/throttleTime.ts
+++ b/src/operator/throttleTime.ts
@@ -9,6 +9,10 @@ export function throttleTime<T>(delay: number, scheduler: Scheduler = asap): Obs
   return this.lift(new ThrottleTimeOperator(delay, scheduler));
 }
 
+export interface ThrottleTimeSignature<T> {
+  (dueTime: number, scheduler?: Scheduler): Observable<T>;
+}
+
 class ThrottleTimeOperator<T> implements Operator<T, T> {
   constructor(private delay: number, private scheduler: Scheduler) {
   }
diff --git a/src/operator/timeInterval.ts b/src/operator/timeInterval.ts
index a8de5032ab..5cba3e2c8b 100644
--- a/src/operator/timeInterval.ts
+++ b/src/operator/timeInterval.ts
@@ -8,6 +8,10 @@ export function timeInterval<T>(scheduler: Scheduler = asap): Observable<TimeInt
   return this.lift(new TimeIntervalOperator(scheduler));
 }
 
+export interface TimeIntervalSignature<T> {
+  (scheduler?: Scheduler): Observable<TimeInterval<T>>;
+}
+
 export class TimeInterval<T> {
   constructor(public value: T, public interval: number) {
 
diff --git a/src/operator/timeout.ts b/src/operator/timeout.ts
index 7738fe6a48..326b0189c2 100644
--- a/src/operator/timeout.ts
+++ b/src/operator/timeout.ts
@@ -13,6 +13,10 @@ export function timeout<T>(due: number | Date,
   return this.lift(new TimeoutOperator(waitFor, absoluteTimeout, errorToSend, scheduler));
 }
 
+export interface TimeoutSignature<T> {
+  (due: number | Date, errorToSend?: any, scheduler?: Scheduler): Observable<T>;
+}
+
 class TimeoutOperator<T> implements Operator<T, T> {
   constructor(private waitFor: number,
               private absoluteTimeout: boolean,
diff --git a/src/operator/timeoutWith.ts b/src/operator/timeoutWith.ts
index 0de6f48171..98e0ea1c9a 100644
--- a/src/operator/timeoutWith.ts
+++ b/src/operator/timeoutWith.ts
@@ -16,6 +16,11 @@ export function timeoutWith<T, R>(due: number | Date,
   return this.lift(new TimeoutWithOperator(waitFor, absoluteTimeout, withObservable, scheduler));
 }
 
+export interface TimeoutWithSignature<T> {
+  (due: number | Date, withObservable: Observable<T>, scheduler?: Scheduler): Observable<T>;
+  <R>(due: number | Date, withObservable: Observable<R>, scheduler?: Scheduler): Observable<T | R>;
+}
+
 class TimeoutWithOperator<T> implements Operator<T, T> {
   constructor(private waitFor: number,
               private absoluteTimeout: boolean,
diff --git a/src/operator/toArray.ts b/src/operator/toArray.ts
index 38b927e8bd..d403b0c837 100644
--- a/src/operator/toArray.ts
+++ b/src/operator/toArray.ts
@@ -6,6 +6,10 @@ export function toArray<T>(): Observable<T[]> {
   return this.lift(new ToArrayOperator());
 }
 
+export interface ToArraySignature<T> {
+  (): Observable<T[]>;
+}
+
 class ToArrayOperator<T> implements Operator<T, T[]> {
   call(subscriber: Subscriber<T[]>): Subscriber<T> {
     return new ToArraySubscriber(subscriber);
diff --git a/src/operator/toPromise.ts b/src/operator/toPromise.ts
index 66196ebe4a..5f42471fa0 100644
--- a/src/operator/toPromise.ts
+++ b/src/operator/toPromise.ts
@@ -18,3 +18,8 @@ export function toPromise<T>(PromiseCtor?: typeof Promise): Promise<T> {
     this.subscribe((x: T) => value = x, (err: any) => reject(err), () => resolve(value));
   });
 }
+
+export interface ToPromiseSignature<T> {
+  (): Promise<T>;
+  (PromiseCtor: typeof Promise): Promise<T>;
+}