diff --git a/hammerjs/hammerjs-1.1.3-tests.ts b/hammerjs/hammerjs-1.1.3-tests.ts
new file mode 100644
index 000000000..42c5ccea3
--- /dev/null
+++ b/hammerjs/hammerjs-1.1.3-tests.ts
@@ -0,0 +1,49 @@
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="hammerjs-1.1.3.d.ts" />
+
+// plugin check
+if (!Hammer.HAS_TOUCHEVENTS && !Hammer.HAS_POINTEREVENTS) {
+    Hammer.plugins.fakeMultitouch();
+    Hammer.plugins.showTouches();
+}
+
+// instance method check
+var el = document.getElementById("container");
+
+Hammer(el).on("doubletap", function () {
+    alert('you doubletapped me!');
+});
+
+var hammertime = Hammer(el, {
+    drag: false,
+    transform: false
+}).off("tap", function (event:HammerEvent) {
+    alert('hello!');
+});
+
+hammertime.enable(false);
+
+hammertime.on("touch drag transform", function (ev: HammerEvent) {
+    if (!ev.gesture) {
+        return;
+    }
+
+    if (ev.gesture.deltaX >= 20) {
+        hammertime.trigger("swipe", ev.gesture);
+    }
+});
+
+// jQuery check
+$("#element")
+   .hammer({
+       // Options
+   })
+   .on("tap", function (ev) {
+       console.log(ev);
+   });
+
+$("#container").hammer({
+    prevent_default: false,
+    drag_block_vertical: false
+}).on("hold tap doubletap transformstart transform transformend dragstart drag dragend release swipe", function (ev) {
+});
\ No newline at end of file
diff --git a/hammerjs/hammerjs-1.1.3.d.ts b/hammerjs/hammerjs-1.1.3.d.ts
new file mode 100644
index 000000000..4e7f69306
--- /dev/null
+++ b/hammerjs/hammerjs-1.1.3.d.ts
@@ -0,0 +1,142 @@
+// Type definitions for Hammer.js 1.1.3
+// Project: http://eightmedia.github.com/hammer.js/
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Drew Noakes <https://drewnoakes.com>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+
+/// <reference path="../jquery/jquery.d.ts"/>
+
+declare var Hammer: HammerStatic;
+
+interface HammerStatic {
+    (element: any, options?: HammerOptions): HammerInstance;
+
+    VERSION: number;
+    HAS_POINTEREVENTS: boolean;
+    HAS_TOUCHEVENTS: boolean;
+    UPDATE_VELOCITY_INTERVAL: number;
+    POINTER_MOUSE: HammerPointerType;
+    POINTER_TOUCH: HammerPointerType;
+    POINTER_PEN: HammerPointerType;
+
+    DIRECTION_UP: HammerDirectionType;
+    DIRECTION_DOWN: HammerDirectionType;
+    DIRECTION_LEFT: HammerDirectionType;
+    DIRECTION_RIGH: HammerDirectionType;
+
+    EVENT_START: HammerTouchEventState;
+    EVENT_MOVE: HammerTouchEventState;
+    EVENT_END: HammerTouchEventState;
+
+    plugins: any;
+    gestures: any;
+    READY: boolean;
+}
+
+declare class HammerInstance {
+    constructor(element: any, options?: HammerOptions);
+
+    on(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
+    off(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
+    enable(toggle: boolean): HammerInstance;
+
+    // You shouldn't normally use this internal method. Only use it when you know what you're doing! You can read the sourcecode for information about how to use this.
+    trigger(gesture: string, eventData: HammerGestureEventData): HammerInstance;
+}
+
+// Gesture Options : https://github.com/EightMedia/hammer.js/wiki/Getting-Started#gesture-options
+interface HammerOptions {
+    behavior?: {
+        contentZooming?: string;
+        tapHighlightColor?: string;
+        touchAction?: string;
+        touchCallout?: string;
+        userDrag?: string;
+        userSelect?: string;
+    };
+    doubleTapDistance?: number;
+    doubleTapInterval?: number;
+    drag?: boolean;
+    dragBlockHorizontal?: boolean;
+    dragBlockVertical?: boolean;
+    dragDistanceCorrection?: boolean;
+    dragLockMinDistance?: number;
+    dragLockToAxis?: boolean;
+    dragMaxTouches?: number;
+    dragMinDistance?: number;
+    gesture?: boolean;
+    hold?: boolean;
+    holdThreshold?: number;
+    holdTimeout?: number;
+    preventDefault?: boolean;
+    preventMouse?: boolean;
+    release?: boolean;
+    showTouches?: boolean;
+    swipe?: boolean;
+    swipeMaxTouches?: number;
+    swipeMinTouches?: number;
+    swipeVelocityX?: number;
+    swipeVelocityY?: number;
+    tap?: boolean;
+    tapAlways?: boolean;
+    tapMaxDistance?: number;
+    tapMaxTime?: number;
+    touch?: boolean;
+    transform?: boolean;
+    transformMinRotation?: number;
+    transformMinScale?: number;
+}
+
+interface HammerGestureEventData {
+    timestamp: number;
+    target: HTMLElement;
+    touches: HammerPoint[];
+    pointerType: HammerPointerType;
+    center: HammerPoint;
+    deltaTime: number;
+    deltaX: number;
+    deltaY: number;
+    velocityX: number;
+    velocityY: number;
+    angle: number;
+    interimAngle: number;
+    direction: HammerDirectionType;
+    interimDirection: HammerDirectionType;
+    distance: number;
+    scale: number;
+    rotation: number;
+    eventType: HammerTouchEventState;
+    srcEvent: any;
+    startEvent: any;
+
+    stopPropagation(): void;
+    preventDefault(): void;
+    stopDetect(): void;
+}
+
+interface HammerPoint {
+    clientX: number;
+    clientY: number;
+    pageX: number;
+    pageY: number;
+}
+
+interface HammerEvent {
+    type: string;
+    gesture: HammerGestureEventData;
+
+    stopPropagation(): void;
+    preventDefault(): void;
+
+}
+
+declare enum HammerPointerType {
+}
+declare enum HammerDirectionType {
+}
+declare enum HammerTouchEventState {
+}
+
+interface JQuery {
+    hammer(options?: HammerOptions): JQuery;
+}
diff --git a/hammerjs/hammerjs-tests.ts b/hammerjs/hammerjs-tests.ts
index 23fa92d4d..a17c16287 100644
--- a/hammerjs/hammerjs-tests.ts
+++ b/hammerjs/hammerjs-tests.ts
@@ -1,49 +1,115 @@
-/// <reference path="../jquery/jquery.d.ts"/>
-/// <reference path="hammerjs.d.ts" />
-
-// plugin check
-if (!Hammer.HAS_TOUCHEVENTS && !Hammer.HAS_POINTEREVENTS) {
-    Hammer.plugins.fakeMultitouch();
-    Hammer.plugins.showTouches();
-}
-
-// instance method check
-var el = document.getElementById("container");
-
-Hammer(el).on("doubletap", function () {
-    alert('you doubletapped me!');
-});
-
-var hammertime = Hammer(el, {
-    drag: false,
-    transform: false
-}).off("tap", function (event:HammerEvent) {
-    alert('hello!');
-});
-
-hammertime.enable(false);
-
-hammertime.on("touch drag transform", function (ev: HammerEvent) {
-    if (!ev.gesture) {
-        return;
-    }
-
-    if (ev.gesture.deltaX >= 20) {
-        hammertime.trigger("swipe", ev.gesture);
-    }
-});
-
-// jQuery check
-$("#element")
-   .hammer({
-       // Options
-   })
-   .on("tap", function (ev) {
-       console.log(ev);
-   });
-
-$("#container").hammer({
-    prevent_default: false,
-    drag_block_vertical: false
-}).on("hold tap doubletap transformstart transform transformend dragstart drag dragend release swipe", function (ev) {
-});
\ No newline at end of file
+// Tests based on examples at http://hammerjs.github.io/examples/
+
+/// <reference path="hammerjs.d.ts" />
+
+(() =>
+{
+  var myElement = document.getElementById( 'myElement' );
+
+  // create a simple instance
+  // by default, it only adds horizontal recognizers
+  var mc = new Hammer( myElement );
+
+  // listen to events...
+  mc.on( "panleft panright tap press", function ( ev )
+  {
+    myElement.textContent = ev.type + " gesture detected.";
+  } );
+})();
+
+
+(() =>
+{
+  var myElement = document.getElementById( 'myElement' );
+
+  // create a simple instance
+  // by default, it only adds horizontal recognizers
+  var mc = new Hammer( myElement );
+
+  // let the pan gesture support all directions.
+  // this will block the vertical scrolling on a touch-device while on the element
+  mc.get( 'pan' ).set( {direction: Hammer.DIRECTION_ALL} );
+
+  // listen to events...
+  mc.on( "panleft panright panup pandown tap press", function ( ev:HammerInput )
+  {
+    myElement.textContent = ev.type + " gesture detected.";
+  } );
+})();
+
+
+(() =>
+{
+  var myElement = document.getElementById( 'myElement' );
+
+  var mc = new Hammer.Manager( myElement );
+
+  // create a pinch and rotate recognizer
+  // these require 2 pointers
+  var pinch = new Hammer.Pinch();
+  var rotate = new Hammer.Rotate();
+
+  // we want to detect both the same time
+  pinch.recognizeWith( rotate );
+
+  // add to the Manager
+  mc.add( [pinch, rotate] );
+
+
+  mc.on( "pinch rotate", function ( ev:HammerInput )
+  {
+    myElement.textContent += ev.type + " ";
+  } );
+})();
+
+
+(() =>
+{
+  var myElement = document.getElementById( 'myElement' );
+
+  // We create a manager object, which is the same as Hammer(), but without the presetted recognizers.
+  var mc = new Hammer.Manager( myElement );
+
+  // Default, tap recognizer
+  mc.add( new Hammer.Tap() );
+
+  // Tap recognizer with minimal 4 taps
+  mc.add( new Hammer.Tap( {event: 'quadrupletap', taps: 4} ) );
+
+  // we want to recognize this simulatenous, so a quadrupletap will be detected even while a tap has been recognized.
+  // the tap event will be emitted on every tap
+  mc.get( 'quadrupletap' ).recognizeWith( 'tap' );
+
+
+  mc.on( "tap quadrupletap", function ( ev )
+  {
+    myElement.textContent += ev.type + " ";
+  } );
+})();
+
+
+(() =>
+{
+  var myElement = document.getElementById( 'myElement' );
+
+  // We create a manager object, which is the same as Hammer(), but without the presetted recognizers.
+  var mc = new Hammer.Manager( myElement );
+
+
+  // Tap recognizer with minimal 2 taps
+  mc.add( new Hammer.Tap( {event: 'doubletap', taps: 2} ) );
+  // Single tap recognizer
+  mc.add( new Hammer.Tap( {event: 'singletap'} ) );
+
+
+  // we want to recognize this simulatenous, so a quadrupletap will be detected even while a tap has been recognized.
+  mc.get( 'doubletap' ).recognizeWith( 'singletap' );
+  // we only want to trigger a tap, when we don't have detected a doubletap
+  mc.get( 'singletap' ).requireFailure( 'doubletap' );
+
+
+  mc.on( "singletap doubletap", function ( ev )
+  {
+    myElement.textContent += ev.type + " ";
+  } );
+})();
\ No newline at end of file
diff --git a/hammerjs/hammerjs.d.ts b/hammerjs/hammerjs.d.ts
index 6f4c0d4ce..a3a7aed42 100644
--- a/hammerjs/hammerjs.d.ts
+++ b/hammerjs/hammerjs.d.ts
@@ -1,142 +1,327 @@
-// Type definitions for Hammer.js 1.1.3
-// Project: http://eightmedia.github.com/hammer.js/
-// Definitions by: Boris Yankov <https://github.com/borisyankov/>, Drew Noakes <https://drewnoakes.com>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
-
-
-/// <reference path="../jquery/jquery.d.ts"/>
-
-declare var Hammer: HammerStatic;
-
-interface HammerStatic {
-    (element: any, options?: HammerOptions): HammerInstance;
-
-    VERSION: number;
-    HAS_POINTEREVENTS: boolean;
-    HAS_TOUCHEVENTS: boolean;
-    UPDATE_VELOCITY_INTERVAL: number;
-    POINTER_MOUSE: HammerPointerType;
-    POINTER_TOUCH: HammerPointerType;
-    POINTER_PEN: HammerPointerType;
-
-    DIRECTION_UP: HammerDirectionType;
-    DIRECTION_DOWN: HammerDirectionType;
-    DIRECTION_LEFT: HammerDirectionType;
-    DIRECTION_RIGH: HammerDirectionType;
-
-    EVENT_START: HammerTouchEventState;
-    EVENT_MOVE: HammerTouchEventState;
-    EVENT_END: HammerTouchEventState;
-
-    plugins: any;
-    gestures: any;
-    READY: boolean;
-}
-
-declare class HammerInstance {
-    constructor(element: any, options?: HammerOptions);
-
-    on(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
-    off(gesture: string, handler: (event: HammerEvent) => void): HammerInstance;
-    enable(toggle: boolean): HammerInstance;
-
-    // You shouldn't normally use this internal method. Only use it when you know what you're doing! You can read the sourcecode for information about how to use this.
-    trigger(gesture: string, eventData: HammerGestureEventData): HammerInstance;
-}
-
-// Gesture Options : https://github.com/EightMedia/hammer.js/wiki/Getting-Started#gesture-options
-interface HammerOptions {
-    behavior?: {
-        contentZooming?: string;
-        tapHighlightColor?: string;
-        touchAction?: string;
-        touchCallout?: string;
-        userDrag?: string;
-        userSelect?: string;
-    };
-    doubleTapDistance?: number;
-    doubleTapInterval?: number;
-    drag?: boolean;
-    dragBlockHorizontal?: boolean;
-    dragBlockVertical?: boolean;
-    dragDistanceCorrection?: boolean;
-    dragLockMinDistance?: number;
-    dragLockToAxis?: boolean;
-    dragMaxTouches?: number;
-    dragMinDistance?: number;
-    gesture?: boolean;
-    hold?: boolean;
-    holdThreshold?: number;
-    holdTimeout?: number;
-    preventDefault?: boolean;
-    preventMouse?: boolean;
-    release?: boolean;
-    showTouches?: boolean;
-    swipe?: boolean;
-    swipeMaxTouches?: number;
-    swipeMinTouches?: number;
-    swipeVelocityX?: number;
-    swipeVelocityY?: number;
-    tap?: boolean;
-    tapAlways?: boolean;
-    tapMaxDistance?: number;
-    tapMaxTime?: number;
-    touch?: boolean;
-    transform?: boolean;
-    transformMinRotation?: number;
-    transformMinScale?: number;
-}
-
-interface HammerGestureEventData {
-    timestamp: number;
-    target: HTMLElement;
-    touches: HammerPoint[];
-    pointerType: HammerPointerType;
-    center: HammerPoint;
-    deltaTime: number;
-    deltaX: number;
-    deltaY: number;
-    velocityX: number;
-    velocityY: number;
-    angle: number;
-    interimAngle: number;
-    direction: HammerDirectionType;
-    interimDirection: HammerDirectionType;
-    distance: number;
-    scale: number;
-    rotation: number;
-    eventType: HammerTouchEventState;
-    srcEvent: any;
-    startEvent: any;
-
-    stopPropagation(): void;
-    preventDefault(): void;
-    stopDetect(): void;
-}
-
-interface HammerPoint {
-    clientX: number;
-    clientY: number;
-    pageX: number;
-    pageY: number;
-}
-
-interface HammerEvent {
-    type: string;
-    gesture: HammerGestureEventData;
-
-    stopPropagation(): void;
-    preventDefault(): void;
-
-}
-
-declare enum HammerPointerType {
-}
-declare enum HammerDirectionType {
-}
-declare enum HammerTouchEventState {
-}
-
-interface JQuery {
-    hammer(options?: HammerOptions): JQuery;
-}
+// Type definitions for Hammer.js 2.0.4
+// Project: http://hammerjs.github.io/
+// Definitions by: Philip Bulley <https://github.com/milkisevil/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare var Hammer:HammerStatic;
+
+interface HammerStatic
+{
+  new( element:HTMLElement, options?:any ): HammerManager;
+
+  defaults:HammerDefaults;
+
+  VERSION: number;
+
+  INPUT_START:  number;
+  INPUT_MOVE:   number;
+  INPUT_END:    number;
+  INPUT_CANCEL: number;
+
+  STATE_POSSIBLE:   number;
+  STATE_BEGAN:      number;
+  STATE_CHANGED:    number;
+  STATE_ENDED:      number;
+  STATE_RECOGNIZED: number;
+  STATE_CANCELLED:  number;
+  STATE_FAILED:     number;
+
+  DIRECTION_NONE:       number;
+  DIRECTION_LEFT:       number;
+  DIRECTION_RIGHT:      number;
+  DIRECTION_UP:         number;
+  DIRECTION_DOWN:       number;
+  DIRECTION_HORIZONTAL: number;
+  DIRECTION_VERTICAL:   number;
+  DIRECTION_ALL:        number;
+
+  Manager:     HammerManager;
+  Input:       HammerInput;
+  TouchAction: TouchAction;
+
+  TouchInput:        TouchInput;
+  MouseInput:        MouseInput;
+  PointerEventInput: PointerEventInput;
+  TouchMouseInput:   TouchMouseInput;
+  SingleTouchInput:  SingleTouchInput;
+
+  Recognizer:     RecognizerStatic;
+  AttrRecognizer: AttrRecognizerStatic;
+  Tap:            TapRecognizerStatic;
+  Pan:            PanRecognizerStatic;
+  Swipe:          SwipeRecognizerStatic;
+  Pinch:          PinchRecognizerStatic;
+  Rotate:         RotateRecognizerStatic;
+  Press:          PressRecognizerStatic;
+
+  on( target:EventTarget, types:string, handler:Function ):void;
+  off( target:EventTarget, types:string, handler:Function ):void;
+  each( obj:any, iterator:Function, context:any ):     void;
+  merge( dest:any, src:any ):    any;
+  extend( dest:any, src:any, merge:boolean ):   any;
+  inherit( child:Function, base:Function, properties:any ):any;
+  bindFn( fn:Function, context:any ):Function;
+  prefixed( obj:any, property:string ):string;
+}
+
+interface HammerDefaults
+{
+  domEvents:boolean;
+  enable:boolean;
+  preset:any[];
+  touchAction:string;
+  cssProps:CssProps;
+
+  inputClass():void;
+  inputTarget():void;
+}
+
+interface CssProps
+{
+  contentZooming:string;
+  tapHighlightColor:string;
+  touchCallout:string;
+  touchSelect:string;
+  userDrag:string;
+  userSelect:string;
+}
+
+interface HammerOptions extends HammerDefaults
+{
+
+}
+
+interface HammerManager
+{
+  new( element:HTMLElement, options?:any ):HammerManager;
+
+  add( recogniser:Recognizer ):Recognizer;
+  add( recogniser:Recognizer ):HammerManager;
+  add( recogniser:Recognizer[] ):Recognizer;
+  add( recogniser:Recognizer[] ):HammerManager;
+  destroy():void;
+  emit( event:string, data:any ):void;
+  get( recogniser:Recognizer ):Recognizer;
+  get( recogniser:string ):Recognizer;
+  off( events:string, handler:( event:HammerInput ) => void ):void;
+  on( events:string, handler:( event:HammerInput ) => void ):void;
+  recognize( inputData:any ):void;
+  remove( recogniser:Recognizer ):HammerManager;
+  remove( recogniser:string ):HammerManager;
+  set( options:HammerOptions ):HammerManager;
+  stop( force:boolean ):void;
+}
+
+declare class HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+
+  destroy():void;
+  handler():void;
+  init():void;
+
+  /** Name of the event. Like panstart. */
+  type:string;
+
+  /** Movement of the X axis. */
+  deltaX:number;
+
+  /** Movement of the Y axis. */
+  deltaY:number;
+
+  /** Total time in ms since the first input. */
+  deltaTime:number;
+
+  /** Distance moved. */
+  distance:number;
+
+  /** Angle moved. */
+  angle:number;
+
+  /** Velocity on the X axis, in px/ms. */
+  velocityX:number;
+
+  /** Velocity on the Y axis, in px/ms */
+  velocityY:number;
+
+  /** Highest velocityX/Y value. */
+  velocity:number;
+
+  /** Direction moved. Matches the DIRECTION constants. */
+  direction:number;
+
+  /** Direction moved from it's starting point. Matches the DIRECTION constants. */
+  offsetDirection:string;
+
+  /** Scaling that has been done when multi-touch. 1 on a single touch. */
+  scale:number;
+
+  /** Rotation that has been done when multi-touch. 0 on a single touch. */
+  rotation:number;
+
+  /** Center position for multi-touch, or just the single pointer. */
+  center:HammerPoint;
+
+  /** Source event object, type TouchEvent, MouseEvent or PointerEvent. */
+  srcEvent:Event;    // TODO: Update to Union Type (TouchEvent | MouseEvent | PointerEvent) if it lands in TS1.4
+
+  /** Target that received the event. */
+  target:HTMLElement;
+
+  /** Primary pointer type, could be touch, mouse, pen or kinect. */
+  pointerType:string;
+
+  /** Event type, matches the INPUT constants. */
+  eventType:string;
+
+  /** true when the first input. */
+  isFirst:boolean;
+
+  /** true when the final (last) input. */
+  isFinal:boolean;
+
+  /** Array with all pointers, including the ended pointers (touchend, mouseup). */
+  pointers:any[];
+
+  /** Array with all new/moved/lost pointers. */
+  changedPointers:any[];
+
+  /** Reference to the srcEvent.preventDefault() method. Only for experts! */
+  preventDefault:Function;
+}
+
+declare class MouseInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class PointerEventInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class SingleTouchInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class TouchInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+declare class TouchMouseInput extends HammerInput
+{
+  constructor( manager:HammerManager, callback:Function );
+}
+
+interface RecognizerStatic
+{
+  new( options?:any ):Recognizer;
+}
+
+interface Recognizer
+{
+  defaults:any;
+
+  canEmit():boolean;
+  canRecognizeWith( otherRecognizer:Recognizer ):boolean;
+  dropRecognizeWith( otherRecognizer:Recognizer ):Recognizer;
+  dropRecognizeWith( otherRecognizer:string ):Recognizer;
+  dropRequireFailure( otherRecognizer:Recognizer ):Recognizer;
+  dropRequireFailure( otherRecognizer:string ):Recognizer;
+  emit( input:HammerInput ):void;
+  getTouchAction():any[];
+  hasRequireFailures():boolean;
+  process( inputData:HammerInput ):string;
+  recognize( inputData:HammerInput ):void;
+  recognizeWith( otherRecognizer:Recognizer ):Recognizer;
+  recognizeWith( otherRecognizer:string ):Recognizer;
+  requireFailure( otherRecognizer:Recognizer ):Recognizer;
+  requireFailure( otherRecognizer:string ):Recognizer;
+  reset():void;
+  set( options?:any ):Recognizer;
+  tryEmit( input:HammerInput ):void;
+}
+
+interface AttrRecognizerStatic
+{
+  attrTest( input:HammerInput ):boolean;
+  process( input:HammerInput ):any;
+}
+
+interface AttrRecognizer extends Recognizer
+{
+  new( options?:any ):AttrRecognizer;
+}
+
+interface PanRecognizerStatic
+{
+  new( options?:any ):PanRecognizer;
+}
+
+interface PanRecognizer extends AttrRecognizer
+{
+}
+
+interface PinchRecognizerStatic
+{
+  new( options?:any ):PinchRecognizer;
+}
+
+interface PinchRecognizer extends AttrRecognizer
+{
+}
+
+interface PressRecognizerStatic
+{
+  new( options?:any ):PressRecognizer;
+}
+
+interface PressRecognizer extends AttrRecognizer
+{
+}
+
+interface RotateRecognizerStatic
+{
+  new( options?:any ):RotateRecognizer;
+}
+
+interface RotateRecognizer extends AttrRecognizer
+{
+}
+
+interface SwipeRecognizerStatic
+{
+  new( options?:any ):SwipeRecognizer;
+}
+
+interface SwipeRecognizer
+{
+}
+
+interface TapRecognizerStatic
+{
+  new( options?:any ):TapRecognizer;
+}
+
+interface TapRecognizer extends AttrRecognizer
+{
+}
+
+declare class TouchAction
+{
+  constructor( manager:HammerManager, value:string );
+
+  compute():string;
+  preventDefaults( input:HammerInput ):void;
+  preventSrc( srcEvent:any ):void;
+  set( value:string ):void;
+  update():void;
+}
+
+interface HammerPoint
+{
+  x: number;
+  y: number;
+}