diff --git a/spec/operators/debounce-spec.ts b/spec/operators/debounce-spec.ts
index 8616e786b1..8cbfa37bf7 100644
--- a/spec/operators/debounce-spec.ts
+++ b/spec/operators/debounce-spec.ts
@@ -2,6 +2,7 @@ import { expect } from 'chai';
 import * as Rx from '../../src/Rx';
 import marbleTestingSignature = require('../helpers/marble-testing'); // tslint:disable-line:no-require-imports
 
+declare const type;
 declare const { asDiagram };
 declare const hot: typeof marbleTestingSignature.hot;
 declare const cold: typeof marbleTestingSignature.cold;
@@ -428,4 +429,20 @@ describe('Observable.prototype.debounce', () => {
 
     expect(results).to.deep.equal([1, 2]);
   });
+
+  type('should support selectors of the same type', () => {
+    /* tslint:disable:no-unused-variable */
+    let o: Rx.Observable<number>;
+    let s: Rx.Observable<number>;
+    let r: Rx.Observable<number> = o.debounce((n) => s);
+    /* tslint:enable:no-unused-variable */
+  });
+
+  type('should support selectors of a different type', () => {
+    /* tslint:disable:no-unused-variable */
+    let o: Rx.Observable<number>;
+    let s: Rx.Observable<string>;
+    let r: Rx.Observable<number> = o.debounce((n) => s);
+    /* tslint:enable:no-unused-variable */
+  });
 });
diff --git a/src/internal/operators/debounce.ts b/src/internal/operators/debounce.ts
index 8477535c0b..e728ecfb6d 100644
--- a/src/internal/operators/debounce.ts
+++ b/src/internal/operators/debounce.ts
@@ -50,12 +50,12 @@ import { MonoTypeOperatorFunction } from '../../internal/types';
  * @method debounce
  * @owner Observable
  */
-export function debounce<T>(durationSelector: (value: T) => SubscribableOrPromise<number>): MonoTypeOperatorFunction<T> {
+export function debounce<T>(durationSelector: (value: T) => SubscribableOrPromise<any>): MonoTypeOperatorFunction<T> {
   return (source: Observable<T>) => source.lift(new DebounceOperator(durationSelector));
 }
 
 class DebounceOperator<T> implements Operator<T, T> {
-  constructor(private durationSelector: (value: T) => SubscribableOrPromise<number>) {
+  constructor(private durationSelector: (value: T) => SubscribableOrPromise<any>) {
   }
 
   call(subscriber: Subscriber<T>, source: any): TeardownLogic {
@@ -74,7 +74,7 @@ class DebounceSubscriber<T, R> extends OuterSubscriber<T, R> {
   private durationSubscription: Subscription = null;
 
   constructor(destination: Subscriber<R>,
-              private durationSelector: (value: T) => SubscribableOrPromise<number>) {
+              private durationSelector: (value: T) => SubscribableOrPromise<any>) {
     super(destination);
   }
 
@@ -95,7 +95,7 @@ class DebounceSubscriber<T, R> extends OuterSubscriber<T, R> {
     this.destination.complete();
   }
 
-  private _tryNext(value: T, duration: SubscribableOrPromise<number>): void {
+  private _tryNext(value: T, duration: SubscribableOrPromise<any>): void {
     let subscription = this.durationSubscription;
     this.value = value;
     this.hasValue = true;
diff --git a/src/internal/patching/operator/debounce.ts b/src/internal/patching/operator/debounce.ts
index f3ec5d3d6e..f7397c1d19 100644
--- a/src/internal/patching/operator/debounce.ts
+++ b/src/internal/patching/operator/debounce.ts
@@ -44,6 +44,6 @@ import { debounce as higherOrder } from '../../operators/debounce';
  * @method debounce
  * @owner Observable
  */
-export function debounce<T>(this: Observable<T>, durationSelector: (value: T) => SubscribableOrPromise<number>): Observable<T> {
+export function debounce<T>(this: Observable<T>, durationSelector: (value: T) => SubscribableOrPromise<any>): Observable<T> {
   return higherOrder(durationSelector)(this);
 }