diff --git a/ace/ace.d.ts b/ace/ace.d.ts
index 8fed295f2..8694777d3 100644
--- a/ace/ace.d.ts
+++ b/ace/ace.d.ts
@@ -653,7 +653,7 @@ declare module AceAjax {
          * @param type Identify the type of the marker
          * @param inFront Set to `true` to establish a front marker
         **/
-        addMarker(range: Range, clazz: string, type: Function, inFront: boolean): void;
+        addMarker(range: Range, clazz: string, type: Function, inFront: boolean): number;
 
         /**
          * Adds a new marker to the given `Range`. If `inFront` is `true`, a front marker is defined, and the `'changeFrontMarker'` event fires; otherwise, the `'changeBackMarker'` event fires.
@@ -662,7 +662,7 @@ declare module AceAjax {
          * @param type Identify the type of the marker
          * @param inFront Set to `true` to establish a front marker
         **/
-        addMarker(range: Range, clazz: string, type: string, inFront: boolean): void;
+        addMarker(range: Range, clazz: string, type: string, inFront: boolean): number;
 
         /**
          * Adds a dynamic marker to the session.
diff --git a/angular-formly/angular-formly.d.ts b/angular-formly/angular-formly.d.ts
index 967a16d10..50a71c125 100644
--- a/angular-formly/angular-formly.d.ts
+++ b/angular-formly/angular-formly.d.ts
@@ -16,32 +16,34 @@ declare module 'angular-formly' {
 
 declare module AngularFormly {
 
-    interface IFieldArray extends Array<IFieldConfigurationObject | IFieldGroup> {
+	interface IFieldArray extends Array<IFieldConfigurationObject | IFieldGroup> {
 
-    }
+	}
 
 	interface IFieldGroup {
 		data?: {
-	            [key: string]: any;
-	        };
+			[key: string]: any;
+		};
 		className?: string;
 		elementAttributes?: string;
-        fieldGroup?: IFieldArray;
+		fieldGroup?: IFieldArray;
 		form?: Object;
 		hide?: boolean;
 		hideExpression?: string | IExpressionFunction;
 		key?: string | number;
-		model?: string | Object;
-        options?: IFormOptionsAPI;
-        templateOptions?: ITemplateOptions;
-        wrapper?: string | string[];
+		model?: string | {
+			[key: string]: any;
+		};
+		options?: IFormOptionsAPI;
+		templateOptions?: ITemplateOptions;
+		wrapper?: string | string[];
 	}
 
 
 	interface IFormOptionsAPI {
 		data?: {
-                    [key: string]: any;
-                };
+			[key: string]: any;
+		};
 		fieldTransform?: Function;
 		formState?: Object;
 		removeChromeAutoComplete?: boolean;
@@ -182,8 +184,8 @@ declare module AngularFormly {
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#data-object
 		 */
 		data?: {
-                    [key: string]: any;
-                };
+			[key: string]: any;
+		};
 
 
 		/**
@@ -287,7 +289,9 @@ declare module AngularFormly {
 		 *
 		 * see http://docs.angular-formly.com/docs/field-configuration-object#model-object--string
 		 */
-		model?: Object | string;
+		model?: string | {
+			[key: string]: any;
+		};
 
 
 		/**
@@ -543,8 +547,8 @@ declare module AngularFormly {
 		defaultOptions?: IFieldConfigurationObject | Function;
 		controller?: Function | string | any[];
 		data?: {
-                    [key: string]: any;
-                };
+			[key: string]: any;
+		};
 		extends?: string;
 		link?: ng.IDirectiveLinkFn;
 		overwriteOk?: boolean;
@@ -612,7 +616,9 @@ declare module AngularFormly {
 		//The index of the field the form is on (in ng-repeat)
 		index: number;
 		//the model of the form (or the model specified by the field if it was specified).
-		model: Object | string;
+		model?: string | {
+			[key: string]: any;
+		};
 		//Shortcut to options.validation.errorExistsAndShouldBeVisible
 		showError: boolean;
 		//Shortcut to options.templateOptions
diff --git a/angular-load/angular-load-tests.ts b/angular-load/angular-load-tests.ts
index b7d7c2e60..7fea2d792 100644
--- a/angular-load/angular-load-tests.ts
+++ b/angular-load/angular-load-tests.ts
@@ -6,7 +6,7 @@ angular.module('app',['angularLoad'])
             ()=>console.log("angular material js loaded")
         );
 
-        angularLoad.loadCss("https://ajax.googleapis.com/ajax/libs/angular_material/1.0.4/angular-material.css").then(
+        angularLoad.loadCSS("https://ajax.googleapis.com/ajax/libs/angular_material/1.0.4/angular-material.css").then(
             ()=>console.log("angular material css loaded")
         );
     }]);
diff --git a/angular-load/angular-load.d.ts b/angular-load/angular-load.d.ts
index 65d5bc388..2a9dc9413 100644
--- a/angular-load/angular-load.d.ts
+++ b/angular-load/angular-load.d.ts
@@ -9,7 +9,7 @@ declare module angular.load {
 
     interface IAngularLoadService {
         loadScript(url:string): ng.IPromise<any>;
-        loadCss(url:string): ng.IPromise<any>;
+        loadCSS(url:string): ng.IPromise<any>;
     }
 
 }
diff --git a/angularjs/angular-tests.ts b/angularjs/angular-tests.ts
index d3d627c27..4bcf96d53 100644
--- a/angularjs/angular-tests.ts
+++ b/angularjs/angular-tests.ts
@@ -272,6 +272,9 @@ module TestQ {
     {
         let result: angular.IPromise<any[]>;
         result = $q.all([promiseAny, promiseAny]);
+        // TS should infer that n1 and n2 are numbers and have toFixed.
+        $q.all([1, $q.when(2)]).then(([ n1, n2 ]) => n1.toFixed() + n2.toFixed());
+        $q.all([1, $q.when(2), '3']).then(([ n1, n2, n3 ]) => n1.toFixed() + n2.toFixed() + n3.slice(1));
     }
     {
         let result: angular.IPromise<TResult[]>;
diff --git a/angularjs/angular.d.ts b/angularjs/angular.d.ts
index f655c21c4..38f761ade 100644
--- a/angularjs/angular.d.ts
+++ b/angularjs/angular.d.ts
@@ -1006,7 +1006,16 @@ declare module angular {
          *
          * @param promises An array of promises.
          */
-        all<T>(promises: IPromise<any>[]): IPromise<T[]>;
+        all<T1, T2, T3, T4, T5, T6, T7, T8, T9, T10>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>, T6 | IPromise<T6>, T7 | IPromise<T7>, T8 | IPromise<T8>, T9 | IPromise<T9>, T10 | IPromise<T10>]): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9, T10]>;
+        all<T1, T2, T3, T4, T5, T6, T7, T8, T9>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>, T6 | IPromise<T6>, T7 | IPromise<T7>, T8 | IPromise<T8>, T9 | IPromise<T9>]): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8, T9]>;
+        all<T1, T2, T3, T4, T5, T6, T7, T8>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>, T6 | IPromise<T6>, T7 | IPromise<T7>, T8 | IPromise<T8>]): IPromise<[T1, T2, T3, T4, T5, T6, T7, T8]>;
+        all<T1, T2, T3, T4, T5, T6, T7>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>, T6 | IPromise<T6>, T7 | IPromise<T7>]): IPromise<[T1, T2, T3, T4, T5, T6, T7]>;
+        all<T1, T2, T3, T4, T5, T6>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>, T6 | IPromise<T6>]): IPromise<[T1, T2, T3, T4, T5, T6]>;
+        all<T1, T2, T3, T4, T5>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>, T5 | IPromise<T5>]): IPromise<[T1, T2, T3, T4, T5]>;
+        all<T1, T2, T3, T4>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>, T4 | IPromise <T4>]): IPromise<[T1, T2, T3, T4]>;
+        all<T1, T2, T3>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>, T3 | IPromise<T3>]): IPromise<[T1, T2, T3]>;
+        all<T1, T2>(values: [T1 | IPromise<T1>, T2 | IPromise<T2>]): IPromise<[T1, T2]>;
+        all<TAll>(promises: IPromise<TAll>[]): IPromise<TAll[]>;
         /**
          * Combines multiple promises into a single promise that is resolved when all of the input promises are resolved.
          *
diff --git a/antd/antd.d.ts b/antd/antd.d.ts
index 96e473c54..ac23dcdc7 100644
--- a/antd/antd.d.ts
+++ b/antd/antd.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Antd v0.12.8
+// Type definitions for Antd v0.12.10
 // Project: http://ant.design
 // Definitions by: bang88 <https://github.com/bang88>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -11,42 +11,91 @@ declare namespace Antd {
 
     // Affix
     interface AffixProps extends React.Props<Affix> {
+        /**
+         * 达到指定偏移量后触发
+         */
         offset?: number
     }
+    /**
+     * # Affix
+     * 将页面元素钉在可视范围。
+     * ## 何时使用
+     * 当内容区域比较长，需要滚动页面时，这部分内容对应的操作或者导航需要在滚动范围内始终展现。常用于侧边菜单和按钮组合。
+     * 页面可视范围过小时，慎用此功能以免遮挡页面内容。
+     */
     export class Affix extends React.Component<AffixProps, {}>{ }
 
 
     // Alert
     interface AlertProps extends React.Props<Alert> {
+        /**
+         * 必选参数，指定警告提示的样式，有四种选择`success`、`info`、`warn`、`error`
+         */
         type: string,
+        /**可选参数，默认不显示关闭按钮 */
         closable?: boolean,
+        /**可选参数，自定义关闭按钮 */
         closeText?: React.ReactNode,
+        /**必选参数，警告提示内容 */
         message: React.ReactNode,
+        /**可选参数，警告提示的辅助性文字介绍 */
         description?: React.ReactNode,
+        /**可选参数，关闭时触发的回调函数 */
         onClose?: Function,
+        /**可选参数，是否显示辅助图标 */
         showIcon?: boolean
     }
+
+
+    /**
+     *  # Alert
+     *  警告提示，展现需要关注的信息。
+
+     * ## 何时使用
+
+     * - 当某个页面需要向用户显示警告的信息时。
+     * - 非浮层的静态展现形式，始终展现，不会自动消失，用户可以点击关闭。
+     * */
     export class Alert extends React.Component<AlertProps, {}>{ }
 
 
     // Badge
+    /**
+     * #Badge
+     *
+     * 图标右上角的圆形徽标数字。
+
+     * ## 何时使用
+
+     * 一般出现在通知图标或头像的右上角，用于显示需要处理的消息条数，通过醒目视觉形式吸引用户处理。
+     *
+    */
     export class Badge extends React.Component<BadgeProps, {}>{ }
     interface BadgeProps extends React.Props<Badge> {
+        /** 展示的数字，大于 overflowCount 时显示为 `${overflowCount}+`，为 0 时隐藏*/
         count: number,
+        /** 展示封顶的数字值*/
         overflowCount?: number,
+        /** 不展示数字，只有一个小红点*/
         dot?: boolean
     }
 
 
     // Button
     interface ButtonProps extends React.Props<Button> {
-
+        /** 设置按钮类型，可选值为 `primary` `ghost` 或者不设 */
         type?: ButtonType | string,
+        /** 设置按钮形状，可选值为 `circle` `circle-outline` 或者不设*/
         shape?: string,
+        /** 设置按钮大小，可选值为 `small` `large` 或者不设*/
         size?: string,
+        /** 设置 `button` 原生的 `type` 值，可选值请参考 HTML标准*/
         htmlType?: string,
+        /** `click` 事件的 handler*/
         onClick?: Function,
+        /** 设置按钮载入状态*/
         loading?: boolean,
+        /** 样式名*/
         className?: string,
     }
 
@@ -58,14 +107,26 @@ declare namespace Antd {
     }
 
     interface ButtonGroupProps extends React.Props<ButtonGroup> {
+        /** 设置按钮大小，可选值为 `small` `large` 或者不设*/
         size?: string
 
     }
+
+    /**
+    可以将多个 `Button` 放入 `Button.Group` 的容器中。
+
+    通过设置 `size` 为 `large` `small` 分别把按钮组合设为大、小尺寸。若不设置 `size`，则尺寸为中。*/
     class ButtonGroup extends React.Component<ButtonGroupProps, {}>{
 
     }
 
+    /**
+     * #Button
+    按钮用于开始一个即时操作。
 
+    ## 何时使用
+
+    标记了一个（或封装一组）操作命令，响应用户点击行为，触发相应的业务逻辑。*/
     export class Button extends React.Component<ButtonProps, {}>{
         static Group: typeof ButtonGroup
     }
@@ -75,16 +136,28 @@ declare namespace Antd {
     // Breadcrumb
 
     interface BreadcrumbItemProps extends React.Props<BreadcrumbItem> {
+        /** 链接，如不传则不可点击   */
         href?: string
     }
     export class BreadcrumbItem extends React.Component<BreadcrumbItemProps, {}>{ }
 
     interface BreadcrumbProps extends React.Props<Breadcrumb> {
+        /** router 的路由栈信息 */
         routes?: Array<React.ReactNode>,
+        /** 路由的参数*/
         params?: Object,
+        /** 分隔符自定义*/
         separator?: string | React.ReactNode
     }
+    /**
+     * #Breadcrumb
+    显示当前页面在系统层级结构中的位置，并能向上返回。
 
+    ## 何时使用
+
+    - 当系统拥有超过两级以上的层级结构时；
+    - 当需要告知用户“你在哪里”时；
+    - 当需要向上导航的功能时。*/
     export class Breadcrumb extends React.Component<BreadcrumbProps, {}>{
         static Item: typeof BreadcrumbItem
     }
@@ -92,49 +165,108 @@ declare namespace Antd {
 
     // Calendar
     interface CalendarProps extends React.Props<Calendar> {
+        /** 自定义渲染月单元格*/
         monthCellRender?: Function,
+        /** 自定义渲染日期单元格*/
         dateCellRender?: Function,
+        /** 是否全屏显示*/
         fullscreen?: boolean,
+        /** 国际化配置*/
         locale?: Object,
         prefixCls?: string,
         className?: string,
         style?: Object,
+        /** 日期面板变化回调*/
         onPanelChange?: Function,
-        value?: Date
+        /** 展示日期*/
+        value?: Date,
+        /** 默认展示日期*/
+        defaultValue?: Date,
+        /** 初始模式，`month/year`*/
+        mode?: string
     }
+    /**
+     * #Calendar
+    按照日历形式展示数据的容器。
+
+    ## 何时使用
+
+    当数据是日期或按照日期划分时，例如日程、课表、价格日历等，农历等。目前支持年/月切换。
+    */
     export class Calendar extends React.Component<CalendarProps, {}>{ }
 
 
     // Carousel
     interface CarouselProps extends React.Props<Carousel> {
+        /** 动画效果函数，可取 scrollx, fade*/
         effect?: string,
+        /** 是否显示面板指示点*/
         dots?: boolean,
+        /** 垂直显示*/
         vertical?: boolean,
+        /** 是否自动切换*/
         autoplay?: boolean,
+        /** 动画效果*/
         easing?: string,
+        /** 切换面板的回调*/
         beforeChange?: Function,
+        /** 切换面板的回调*/
         afterChange?: Function
     }
+    /**
+     * #Carousel
+    旋转木马，一组轮播的区域。
 
+    ## 何时使用
+
+    - 当有一组平级的内容。
+    - 当内容空间不足时，可以用走马灯的形式进行收纳，进行轮播展现。
+    - 常用于一组图片或卡片轮播。
+    */
     export class Carousel extends React.Component<CarouselProps, {}>{ }
 
 
 
     // Cascader
     interface CascaderProps extends React.Props<Cascader> {
+        /** 可选项数据源*/
         options: Object,
+        /** 默认的选中项*/
         defaultValue?: Array<any>,
+        /** 指定选中项*/
         value?: Array<any>,
+        /** 选择完成后的回调*/
         onChange?: Function,
+        /** 选择后展示的渲染函数*/
         displayRender?: Function,
+        /** 自定义样式*/
+        style?: Object,
+        /** 自定义类名*/
+        className?: string,
+        /** 自定义浮层类名*/
         popupClassName?: string,
+        /** 浮层预设位置：`bottomLeft` `bottomRight` `topLeft` `topRight` */
         popupPlacement?: string,
+        /** 输入框占位文本*/
         placeholder?: string,
+        /** 输入框大小，可选 `large` `default` `small` */
         size?: string,
+        /** 禁用*/
         disabled?: boolean,
+        /** 是否支持清除*/
         allowClear?: boolean
 
     }
+    /**
+     * #Cascader
+    级联选择框。
+
+
+    ## 何时使用
+
+    - 需要从一组相关联的数据集合进行选择，例如省市区，公司层级，事物分类等。
+    - 从一个较大的数据集合中进行选择时，用多级分类进行分隔，方便选择。
+    - 比起 Select 组件，可以在同一个浮层中完成选择，有较好的体验。*/
     export class Cascader extends React.Component<CascaderProps, {}>{ }
 
 
@@ -142,18 +274,35 @@ declare namespace Antd {
 
     // Checkbox
     interface CheckboxProps extends React.Props<Checkbox> {
+        /** 指定当前是否选中*/
         checked?: boolean,
+        /** 初始是否选中*/
         defaultChecked?: boolean,
+        /** 变化时回调函数*/
         onChange?: Function
     }
 
     interface CheckboxGroupProps extends React.Props<CheckboxGroup> {
+        /** 默认选中的选项*/
         defaultValue?: Array<any>,
+        /** 指定选中的选项*/
         value?: Array<any>,
+        /** 指定可选项*/
         options?: Array<any>,
+        /** 变化时回调函数*/
         onChange?: Function
     }
+    /** Checkbox 组*/
     class CheckboxGroup extends React.Component<CheckboxGroupProps, {}>{ }
+    /**
+     * #Checkbox
+    多选框。
+
+    ## 何时使用
+
+    - 在一组可选项中进行多项选择时；
+    - 单独使用可以表示两种状态之间的切换，和 `switch` 类似。区别在于切换 `switch` 会直接触发状态改变，而 `checkbox` 一般用于状态标记，需要和提交操作配合。
+    */
     export class Checkbox extends React.Component<CheckboxProps, {}>{
         static Group: typeof CheckboxGroup
     }
@@ -163,13 +312,28 @@ declare namespace Antd {
     // Collapse
 
     interface CollapseProps extends React.Props<Collapse> {
-
+        /** 当前激活 tab 面板的 key*/
         activeKey?: Array<any> | string,
+        /** 初始化选中面板的key */
         defaultActiveKey?: Array<string>,
+        /** 切换面板的回调*/
         onChange?: Function
 
     }
-    class CollapsePanel extends React.Component<{ key: string, header: React.ReactNode | string }, {}>{ }
+    class CollapsePanel extends React.Component<{
+        /** 对应 activeKey */
+        key: string,
+        /** 面板头内容*/
+        header: React.ReactNode | string
+    }, {}>{ }
+    /**
+     * #Collapse
+    可以折叠/展开的内容区域。
+
+    ## 何时使用
+
+    - 对复杂区域进行分组和隐藏，保持页面的整洁。
+    - `手风琴` 是一种特殊的折叠面板，只允许单个内容区域展开。*/
     export class Collapse extends React.Component<CollapseProps, {}>{
         static Panel: typeof CollapsePanel
     }
@@ -181,16 +345,26 @@ declare namespace Antd {
 
         value?: string | Date,
         defaultValue?: string | Date,
+        /** 展示的日期格式，配置参考 [GregorianCalendarFormat](https://github.com/yiminghe/gregorian-calendar-format)*/
         format?: string,
+        /** 不可选择的日期*/
         disabledDate?: Function,
+        /** 时间发生变化的回调，发生在用户选择时间时*/
         onChange?: Function,
+        /** 禁用*/
         disabled?: boolean,
         style?: Object,
+        /** 格外的弹出日历样式*/
         popupStyle?: Object,
+        /** 输入框大小，`large` 高度为 32px，`small` 为 22px，默认是 28px*/
         size?: string,
+        /** 国际化配置*/
         locale?: Object,
+        /** 增加时间选择功能*/
         showTime?: boolean,
+        /** 点击确定按钮的回调*/
         onOk?: Function,
+        /** 定义浮层的容器，默认为 body 上新建 div*/
         getCalendarContainer?: Function
 
     }
@@ -199,7 +373,13 @@ declare namespace Antd {
     }
     class RangePicker extends React.Component<RangePickProps, {}>{ }
     class MonthPicker extends React.Component<RangePickProps, {}>{ }
+    /**
+     * #DatePicker
+    输入或选择日期的控件。
 
+    ## 何时使用
+
+    当用户需要输入一个日期，可以点击标准输入框，弹出日期面板进行选择。*/
     export class DatePicker extends React.Component<DatePickerProps<any>, {}>{
         static RangePicker: typeof RangePicker
         static MonthPicker: typeof MonthPicker
@@ -211,18 +391,31 @@ declare namespace Antd {
     // Dropdown
 
     interface DropdownProps extends React.Props<Dropdown> {
-
+        /** 触发下拉的行为  ['click'] or ['hover']*/
         trigger?: Array<string>,
+        /** 菜单节点*/
         overlay: React.ReactNode
 
     }
 
     class DropdownButton extends React.Component<{
+        /**  按钮类型*/
         type?: string,
+        /** 点击左侧按钮的回调*/
         onClick?: Function,
+        /** 触发下拉的行为*/
         trigger?: string,
+        /** 菜单节点*/
         overlay: React.ReactNode
     }, {}>{ }
+    /**
+     * #Dropdown
+    向下弹出的列表。
+
+    ## 何时使用
+
+    当页面上的操作命令过多时，用此组件可以收纳操作元素。点击或移入触点，会出现一个下拉菜单。可在列表中进行选择，并执行相应的命令。
+    */
     export class Dropdown extends React.Component<DropdownProps, {}>{
         static Button: typeof DropdownButton
     }
@@ -233,55 +426,108 @@ declare namespace Antd {
 
     interface FormItemProps extends React.Props<FormItem> {
         prefixCls?: string,
+        /**  label 标签的文本*/
         label?: React.ReactNode,
+        /** label 标签布局，通 `<Col>` 组件，设置 `span` `offset` 值，如 `{span: 3, offset: 12}`*/
         labelCol?: Object,
+        /** 提示信息，如不设置，则会根据校验规则自动生成 */
         help?: React.ReactNode | boolean,
+        /** 额外的提示信息，和 help 类似，当需要错误信息和提示文案同时出现时，可以使用这个。*/
         extra?: string,
+        /** 是否必填，如不设置，则会根据校验规则自动生成 */
         validateStatus?: string,
+        /** 配合 validateStatus 属性使用，是否展示校验状态图标 */
         hasFeedback?: boolean,
+        /** 需要为输入控件设置布局样式时，使用该属性，用法同 labelCol*/
         wrapperCol?: Object,
         className?: string,
         required?: boolean,
         id?: string
     }
+    /**
+    表单一定会包含表单域，表单域可以是输入控件，标准表单域，标签，下拉菜单，文本域等。
 
+    这里我们分别封装了表单域 `<Form.Item />` 和输入控件 `<Input />`。*/
     export class FormItem extends React.Component<FormItemProps, {}>{ }
-
+    interface FormComponentProps extends React.Props<FormComponent> {
+        form: CreateFormOptions
+    }
+    export class FormComponent extends React.Component<FormComponentProps, {}>{ }
 
     // function  create
     type CreateFormOptions = {
+        /** 获取一组输入控件的值，如不传入参数，则获取全部组件的值*/
         getFieldsValue(): (fieldNames?: Array<string>) => any
+        /** 获取一个输入控件的值*/
         getFieldValue(): (fieldName: string) => any
+        /** 设置一组输入控件的值*/
         setFieldsValue(): (obj: Object) => void
+        /** 设置一组输入控件的值*/
         setFields(): (obj: Object) => void
+        /** 校验并获取一组输入域的值与 Error*/
         validateFields(): (fieldNames?: Array<string>, options?: Object, callback?: (erros: any, values: any) => void) => any
+        /** 与 `validateFields` 相似，但校验完后，如果校验不通过的菜单域不在可见范围内，则自动滚动进可见范围 */
         validateFieldsAndScroll(): (fieldNames?: Array<string>, options?: Object, callback?: (erros: any, values: any) => void) => any
+        /** 获取某个输入控件的 Error */
         getFieldError(): (name: string) => Object
+        /** 判断一个输入控件是否在校验状态*/
         isFieldValidating(): (name: string) => Object
-
+        /**重置一组输入控件的值与状态，如不传入参数，则重置所有组件*/
         resetFields(): (names?: Array<string>) => void
 
         getFieldsValue(): (id: string, options: {
+            /** 子节点的值的属性，如 Checkbox 的是 'checked'*/
             valuePropName?: string,
+            /** 子节点的初始值，类型、可选值均由子节点决定*/
             initialValue?: any,
+            /** 收集子节点的值的时机*/
             trigger?: string,
+            /** 校验子节点值的时机*/
             validateTrigger?: string,
-            rules?: Array<any>
+            /** 校验规则，参见 [async-validator](https://github.com/yiminghe/async-validator) */
+            rules?: Array<any>,
+            /** 必填输入控件唯一标志*/
+            id?: string
         }) => Array<any>
 
 
     }
 
+    interface ComponentDecorator {
+        <T extends (typeof FormComponent)>(component: T): T;
+    }
     interface FormProps extends React.Props<Form> {
         prefixCls?: string,
+        /** 水平排列布局*/
         horizontal?: boolean,
+        /** 行内排列布局*/
         inline?: boolean,
+        /** 经 `Form.create()` 包装过的组件会自带 `this.props.form` 属性，直接传给 Form 即可*/
         form?: Object,
+        /** 数据验证成功后回调事件*/
         onSubmit?: (e: React.FormEvent) => void,
     }
+    /**
+     * #Form
+    具有数据收集、校验和提交功能的表单，包含复选框、单选框、输入框、下拉选择框等元素。
+
+    ## 表单
+
+    我们为 `form` 提供了以下两种排列方式：
+
+    - 水平排列：可以实现 `label` 标签和表单控件的水平排列;
+    - 行内排列：使其表现为 `inline-block` 级别的控件。
+    */
     export class Form extends React.Component<FormProps, {}>{
         static Item: typeof FormItem
-        static create(options?: CreateFormOptions): Function
+        static create(options?: {
+            /**
+             *   当 `Form.Item` 子节点的值发生改变时触发，可以把对应的值转存到 Redux store
+             */
+            onFieldsChange?: (props: Object, fields: Array<any>) => void,
+            /**  把 props 转为对应的值，可用于把 Redux store 中的值读出 */
+            mapPropsToFields?: (props: Object) => void
+        }): ComponentDecorator
     }
 
 
@@ -290,8 +536,34 @@ declare namespace Antd {
 
     // Icon
     interface IconProps extends React.Props<Icon> {
+        /** 图标类型*/
         type: string
     }
+    /**
+     * #Icon
+    有含义的矢量图形，每一个图标打倒一个敌人。
+
+    ## 图标的命名规范
+
+    我们为每个图标赋予了语义化的命名，命名规则如下:
+
+    - 实心和描线图标保持同名，用 `-o` 来区分，比如 `question-circle`(实心) 和 `question-circle-o`(描线)；
+
+    - 命名顺序：`[icon名]-[形状可选]-[描线与否]-[方向可选]`。
+
+    ## 如何使用
+
+    使用 `<Icon />` 标签声明组件，指定图标对应的 type 属性，示例代码如下:
+
+    ```html
+    <Icon type="link" />
+    ```
+
+    最终会渲染为：
+
+    ```html
+    <i class="anticon anticon-${type}"></i>
+    ```*/
     export class Icon extends React.Component<IconProps, {}>{ }
 
 
@@ -299,14 +571,20 @@ declare namespace Antd {
 
     // Input
     interface InputProps extends React.Props<Input> {
+        /**  【必须】声明 input 类型，同原生 input 标签的 type 属性*/
         type?: string,
         id: string | number,
+        /** 控件大小，默认值为 default 。注：标准表单内的输入框大小限制为 large。 {'large','default','small'}*/
         size?: string,
+        /** 是否禁用状态，默认为 false*/
         disabled?: boolean,
         value?: any,
+        /** 设置初始默认值*/
         defaultValue?: any,
         className?: string,
+        /** 带标签的 input，设置前置标签*/
         addonBefore?: React.ReactNode,
+        /** 带标签的 input，设置后置标签*/
         addonAfter?: React.ReactNode,
         prefixCls?: string,
         placeholder?: string
@@ -318,17 +596,31 @@ declare namespace Antd {
 
     // InputNumber
     interface InputNumberProps extends React.Props<InputNumber> {
-
+        /** 最小值*/
         min: number,
+        /** 最大值*/
         max: number,
+        /** 当前值*/
         value?: number,
+        /** 每次改变步数*/
         step?: number,
+        /** 初始值*/
         defaultValue?: number,
+        /** 变化回调*/
         onChange?: Function,
+        /** 禁用*/
         disabled?: boolean,
+        /** 输入框大小*/
         size?: string
 
     }
+    /**
+     * #InputNumber
+    通过鼠标或键盘，输入范围内的数值。
+
+    ## 何时使用
+
+    当需要获取标准数值时。*/
     export class InputNumber extends React.Component<InputNumberProps, {}>{ }
 
 
@@ -351,6 +643,25 @@ declare namespace Antd {
         pull?: string,
         className?: string
     }
+    /**
+    在多数业务情况下，Ant Design需要在设计区域内解决大量信息收纳的问题，因此在12栅格系统的基础上，我们将整个设计建议区域按照24等分的原则进行划分。
+
+    划分之后的信息区块我们称之为“盒子”。建议横向排列的盒子数量最多四个，最少一个。“盒子”在整个屏幕上占比见上图。设计部分基于盒子的单位定制盒子内部的排版规则，以保证视觉层面的舒适感。
+
+    ## 概述
+
+    布局的栅格化系统，我们是基于行（row）和列（col）来定义信息区块的外部框架，以保证页面的每个区域能够稳健地排布起来。下面简单介绍一下它的工作原理：
+
+    * 通过`row`在水平方向建立一组`column`（简写col）
+    * 你的内容应当放置于`col`内，并且，只有`col`可以作为`row`的直接元素
+    * 栅格系统中的列是指1到24的值来表示其跨越的范围。例如，三个等宽的列可以使用`.col-8`来创建
+    * 如果一个`row`中的`col`总和超过24，那么多余的`col`会作为一个整体另起一行排列
+
+    ## Flex 布局
+
+    我们的栅格化系统支持 Flex 布局，允许子元素在父节点内的水平对齐方式 - 居左、居中、居右、等宽排列、分散排列。子元素与子元素之间，支持顶部对齐、垂直居中对齐、底部对齐的方式。同时，支持使用 order 来定义元素的排列顺序。
+
+    Flex 布局是基于 24 栅格来定义每一个“盒子”的宽度，但排版则不拘泥于栅格。*/
     export class Col extends React.Component<ColProps, {}>{ }
 
 
@@ -358,19 +669,44 @@ declare namespace Antd {
 
     // Menu
     interface MenuItemProps extends React.Props<MenuItem> {
+        /**
+         * (是否禁用)
+         *
+         * @type {boolean}
+         */
         disabled?: boolean,
         key: string
     }
     export class MenuItem extends React.Component<MenuItemProps, {}>{ }
 
     interface MenuSubMenuProps extends React.Props<MenuSubMenu> {
+        /**
+         * (子菜单项值)
+         *
+         * @type {(string | React.ReactNode)}
+         */
         title: string | React.ReactNode,
+        /**
+         * (子菜单的菜单项)
+         *
+         * @type {(MenuItem | MenuSubMenu)}
+         */
         children?: MenuItem | MenuSubMenu
     }
     export class MenuSubMenu extends React.Component<MenuSubMenuProps, {}>{ }
 
     interface MenuItemGroupProps extends React.Props<MenuItemGroup> {
+        /**
+         * (分组标题)
+         *
+         * @type {(string | React.ReactNode)}
+         */
         title: string | React.ReactNode,
+        /**
+         * (分组的菜单项)
+         *
+         * @type {MenuItem}
+         */
         children?: MenuItem
     }
     export class MenuItemGroup extends React.Component<MenuItemGroupProps, {}>{ }
@@ -387,17 +723,40 @@ declare namespace Antd {
         inline
     }
     interface MenuProps extends React.Props<Menu> {
+        /** 主题颜色*/
         theme?: MenuTheme | string,
+        /** 菜单类型  enum: `vertical` `horizontal` `inline`*/
         mode?: MenuMode | string,
+        /** 当前选中的菜单项 key 数组*/
         selectedKeys?: Array<string>,
+        /** 初始选中的菜单项 key 数组*/
         defaultSelectedKeys?: Array<string>,
+        /** 当前展开的菜单项 key 数组*/
         openKeys?: Array<string>,
+        /** 初始展开的菜单项 key 数组*/
         defaultOpenKeys?: Array<string>,
+        /**
+         * 被选中时调用
+         *
+         * @type {(item: any, key: string, selectedKeys: Array<string>) => void}
+         */
         onSelect?: (item: any, key: string, selectedKeys: Array<string>) => void,
+        /** 取消选中时调用*/
         onDeselect?: (item: any, key: string, selectedKeys: Array<string>) => void,
+        /** 点击 menuitem 调用此函数*/
         onClick?: (item: any, key: string) => void,
+        /** 根节点样式*/
         style?: Object
     }
+    /**
+    # Menu
+    为页面和功能提供导航的菜单列表。
+
+    ## 何时使用
+
+    导航菜单是一个网站的灵魂，用户依赖导航在各个页面中进行跳转。一般分为顶部导航和侧边导航，顶部导航提供全局性的类目和功能，侧边导航提供多级结构来收纳和排列网站架构。
+
+    更多布局和导航的范例可以参考：[常用布局](/spec/layout)。*/
     export class Menu extends React.Component<MenuProps, {}>{
         static Item: typeof MenuItem
         static SubMenu: typeof MenuSubMenu
@@ -408,13 +767,34 @@ declare namespace Antd {
 
 
     // Message
-    type MessageFunc = (content: string, duration?: number) => void
+    type MessageFunc = (
+        /** 提示内容*/
+        content: string,
+        /** 自动关闭的延时*/
+        duration?: number
+    ) => void
+    /**
+     * #Message
+    全局展示操作反馈信息。
+
+    ## 何时使用
+
+    - 可提供成功、警告和错误等反馈信息。
+    - 顶部居中显示并自动消失，是一种不打断用户操作的轻量级提示方式。*/
     export const message: {
+
         success: MessageFunc
         error: MessageFunc
         info: MessageFunc
         loading: MessageFunc
-        config: (options: { top: number }) => void
+        config: (options: {
+            /**
+             * 消息距离顶部的位置
+             *
+             * @type {number}
+             */
+            top: number
+        }) => void
         destroy: () => void
     }
 
@@ -431,21 +811,39 @@ declare namespace Antd {
     }) => void
 
     interface ModalProps extends React.Props<Modal> {
+        /** 对话框是否可见*/
         visible?: boolean,
+        /** 确定按钮 loading*/
         confirmLoading?: boolean,
-
+        /** 标题*/
         title?: React.ReactNode | string,
-
+        /** 是否显示右上角的关闭按钮*/
         closable?: boolean,
+        /** 点击确定回调*/
         onOk?: Function,
+        /** 点击遮罩层或右上角叉或取消按钮的回调*/
         onCancel?: Function,
+        /** 宽度*/
         width?: string | number,
+        /** 底部内容*/
         footer?: React.ReactNode | string,
-
+        /** 确认按钮文字*/
         okText?: string,
+        /** 取消按钮文字*/
         cancelText?: string,
+        /** 点击蒙层是否允许关闭*/
         maskClosable?: boolean
     }
+
+    /**
+    # Modal
+    模态对话框。
+
+    ## 何时使用
+
+    需要用户处理事务，又不希望跳转页面以致打断工作流程时，可以使用 `Modal` 在当前页面正中打开一个浮层，承载相应的操作。
+
+    另外当需要一个简洁的确认框询问用户时，可以使用精心封装好的 `ant.Modal.confirm()` 等方法。*/
     export class Modal extends React.Component<ModalProps, {}>{
         static info: ModalFunc
         static success: ModalFunc
@@ -459,14 +857,30 @@ declare namespace Antd {
     // Notification
     type NotificationFunc = (
         config: {
+            /** 通知提醒标题，必选 */
             message: React.ReactNode | string,
+            /** 通知提醒内容，必选*/
             description: React.ReactNode | string,
+            /** 自定义关闭按钮*/
             btn?: React.ReactNode | string,
+            /** 当前通知唯一标志*/
             key?: string,
+            /** 点击默认关闭按钮时触发的回调函数*/
             onClose?: Function,
+            /** 默认 4.5 秒后自动关闭，配置为 null 则不自动关闭*/
             duration?: number
         }) => void
+    /**
+     * #Notification
+    全局展示通知提醒信息。
 
+    ## 何时使用
+
+    在系统右上角显示通知提醒信息。经常用于以下情况：
+
+    - 较为复杂的通知内容。
+    - 带有交互的通知，给出用户下一步的行动点。
+    - 系统主动推送。*/
     export const Notification: {
         success: NotificationFunc
         error: NotificationFunc
@@ -474,7 +888,10 @@ declare namespace Antd {
         warn: NotificationFunc
         close: (key: string) => void
         destroy: () => void
-        config: (options: { top: number }) => void
+        config: (options: {
+            /** 消息距离顶部的位置*/
+            top: number
+        }) => void
 
     }
 
@@ -483,20 +900,41 @@ declare namespace Antd {
 
     // Pagination
     interface PaginationProps extends React.Props<Pagination> {
+        /** 当前页数*/
         current?: number,
+        /** 默认的当前页数*/
         defaultCurrent?: number,
+        /** 数据总数*/
         total: number,
+        /** 初始的每页条数*/
         defaultPageSize?: number,
+        /** 每页条数*/
         pageSize?: number,
+        /** 页码改变的回调，参数是改变后的页码*/
         onChange?: Function,
+        /** 是否可以改变 pageSize */
         showSizeChanger?: boolean,
+        /** 指定每页可以显示多少条*/
         pageSizeOptions?: Array<number>
+        /** pageSize 变化的回调  */
         onShowSizeChange?: Function,
+        /** 是否可以快速跳转至某页*/
         showQuickJumper?: boolean,
+        /** 当为「small」时，是小尺寸分页 */
         size?: string,
+        /** 当添加该属性时，显示为简单分页*/
         simple?: Object,
+        /** 用于显示总共有多少条数据*/
         showTotal?: Function
     }
+    /**
+     * #Pagination
+    采用分页的形式分隔长列表，每次只加载一个页面。
+
+    ## 何时使用
+
+    - 当加载/渲染所有数据将花费很多时间时；
+    - 可切换页码浏览数据。*/
     export class Pagination extends React.Component<PaginationProps, {}>{ }
 
 
@@ -507,14 +945,34 @@ declare namespace Antd {
         top, left, right, bottom
     }
     interface PopconfirmProps extends React.Props<Popconfirm> {
+        /**
+         * 气泡框位置，可选 `top/left/right/bottom`
+         *
+         * @type {(Placement | string)}
+         */
         placement?: Placement | string,
+        /** 确认框的描述*/
         title?: string,
+        /** 点击确认的回调*/
         onConfirm?: Function,
         onCancel?: Function,
+        /** 显示隐藏的回调*/
         onVisibleChange?: (visible: boolean) => void,
+        /** 确认按钮文字*/
         okText?: string,
+        /** 取消按钮文字*/
         cancelText?: string
     }
+    /**
+     * #Popconfirm
+    点击元素，弹出气泡式的确认框。
+
+    ## 何时使用
+
+    目标元素的操作需要用户进一步的确认时，在目标元素附近弹出浮层提示，询问用户。
+
+    和 `confirm` 弹出的全屏居中模态对话框相比，交互形式更轻量。
+    */
     export class Popconfirm extends React.Component<PopconfirmProps, {}>{ }
 
 
@@ -531,14 +989,30 @@ declare namespace Antd {
         leftTop, leftBottom, rightTop, rightBottom
     }
     interface PopoverProps extends React.Props<Popover> {
+        /** 触发行为，可选 `hover/focus/click` */
         trigger?: Trigger | string,
+        /** 气泡框位置，可选 `top/left/right/bottom` `topLeft/topRight/bottomLeft/bottomRight` `leftTop/leftBottom/rightTop/rightBottom`*/
         placement?: PopoverPlacement | string,
+        /** 卡片标题*/
         title?: React.ReactNode | string,
+        /** 卡片内容*/
         overlay?: React.ReactNode | string,
         prefixCls?: string,
+        /** 用于手动控制浮层显隐*/
         visible?: boolean,
+        /** 显示隐藏改变的回调*/
         onVisibleChange?: Function
     }
+    /**
+     * #Popover
+    点击/鼠标移入元素，弹出气泡式的卡片浮层。
+
+    ## 何时使用
+
+    当目标元素有进一步的描述和相关操作时，可以收纳到卡片中，根据用户的操作行为进行展现。
+
+    和 `Tooltip` 的区别是，用户可以对浮层上的元素进行操作，因此它可以承载更复杂的内容，比如链接或按钮等。
+    */
     export class Popover extends React.Component<PopoverProps, {}>{ }
 
 
@@ -552,23 +1026,42 @@ declare namespace Antd {
     }
 
     interface LineProps extends React.Props<Line> {
+        /** 百分比*/
         percent: number,
+        /** 内容的模板函数*/
         format?: (percent: any) => void,
+        /** 状态，可选：normal、exception、active*/
         status?: ProgressStatus | string,
+        /** 进度条线的宽度，单位是px*/
         strokeWidth?: number,
+        /** 是否显示进度数值和状态图标*/
         showInfo?: boolean
     }
     export class Line extends React.Component<LineProps, {}>{ }
 
     interface CircleProps extends React.Props<Circle> {
+        /** 百分比*/
         percent: number,
+        /** 内容的模板函数*/
         format?: (percent: any) => void,
+        /** 状态，可选：normal、exception*/
         status?: ProgressStatus | string,
+        /** 进度条线的宽度，单位是进度条画布宽度的百分比*/
         strokeWidth?: number,
+        /** 必填，进度条画布宽度，单位px。这里没有提供height属性设置，Line型高度就是strokeWidth，Circle型高度等于width*/
         width?: number
     }
     export class Circle extends React.Component<CircleProps, {}>{ }
+    /**
+     * #Progress
+    展示操作的当前进度。
 
+    ## 何时使用
+
+    在操作需要较长时间才能完成时，为用户显示该操作的当前进度和状态。
+
+    * 当一个操作会打断当前界面，或者需要在后台运行，且耗时可能超过2秒时；
+    * 当需要显示一个操作完成的百分比时。*/
     export const Progress: {
         Line: typeof Line,
         Circle: typeof Circle
@@ -577,16 +1070,37 @@ declare namespace Antd {
 
     // QueueAnim
     interface QueueAnimProps extends React.Props<QueueAnim> {
+        /** 动画内置参数 `left` `right` `top` `bottom` `scale` `scaleBig` `scaleX` `scaleY`*/
         type?: string | Array<string>,
+        /** 配置动画参数 如 `{opacity:[1, 0],translateY:[0, -30]}` 具体参考 [velocity](http://julian.com/research/velocity) 的写法*/
         animConfig?: Object | Array<any>,
+        /** 整个动画的延时,以毫秒为单位*/
         delay?: number | Array<any>,
+        /** 每个动画的时间,以毫秒为单位*/
         duration?: number | Array<any>,
+        /** 每个动画的间隔时间,以毫秒为单位*/
         interval?: number | Array<any>,
+        /** 出场时是否倒放,从最后一个 dom 开始往上播放 */
         leaveReverse?: boolean,
+        /** 动画的缓动函数,[查看详细](http://julian.com/research/velocity/#easing)*/
         ease?: string | Array<any>,
+        /** 进出场动画进行中的类名*/
         animatingClassName?: Array<string>,
+        /** QueueAnim 替换的标签名*/
         component?: string
     }
+    /**
+     * #QueueAnim
+    通过简单的配置对一组元素添加串行的进场动画效果。
+
+    ## 何时使用
+
+    - 从内容A到内容B的转变过程时能有效的吸引用户注意力，突出视觉中心，提高整体视觉效果。
+
+    - 小的信息元素排布或块状较多的情况下，根据一定的路径层次依次进场，区分维度层级，来凸显量级，使页面转场更加流畅和舒适，提高整体视觉效果和产品的质感。
+
+    - 特别适合首页和需要视觉展示效果的宣传页，以及单页应用的切换页面动效。
+    */
     export class QueueAnim extends React.Component<QueueAnimProps, {}>{ }
 
 
@@ -599,19 +1113,35 @@ declare namespace Antd {
         small
     }
     interface RadioGroupProps extends React.Props<RadioGroup> {
+        /** 选项变化时的回调函数*/
         onChange?: (e: Event) => void,
+        /** 用于设置当前选中的值*/
         value?: string,
+        /** 默认选中的值*/
         defaultValue?: string,
+        /**  大小，只对按钮样式生效*/
         size?: RadioGroupSize | string
     }
     export class RadioGroup extends React.Component<RadioGroupProps, {}>{ }
 
 
     interface RadioProps extends React.Props<Radio> {
+        /** 指定当前是否选中*/
         checked?: boolean,
+        /** 初始是否选中*/
         defaultChecked?: boolean,
+        /** 根据 value 进行比较，判断是否选中  */
         value?: any
     }
+    /**
+     * #Radio
+    单选框。
+
+    ## 何时使用
+
+    - 用于在多个备选项中选中单个状态。
+    - 和 Select 的区别是，Radio 所有选项默认可见，方便用户在比较中选择，因此选项不宜过多。
+    */
     export class Radio extends React.Component<RadioProps, {}>{
         static Group: typeof RadioGroup
         static Button: typeof Button
@@ -621,40 +1151,70 @@ declare namespace Antd {
 
     // Select
     interface SelectOptionProps extends React.Props<SelectOption> {
+        /** 是否禁用*/
         disabled?: boolean,
+        /** 如果 react 需要你设置此项，此项值与 value 的值相同，然后可以省略 value 设置*/
         key?: string,
+        /** 默认根据此属性值进行筛选*/
         value: string
     }
     export class SelectOption extends React.Component<SelectOptionProps, {}>{ }
 
     interface SelectOptGroupProps extends React.Props<SelectOptGroup> {
+        /** 组名*/
         label: string | React.ReactNode,
         key?: string
     }
     export class SelectOptGroup extends React.Component<SelectOptGroupProps, {}>{ }
 
     interface SelectProps extends React.Props<Select> {
+        /** 指定当前选中的条目*/
         value?: string | Array<any>,
+        /** 指定默认选中的条目*/
         defaultValue?: string | Array<any>,
+        /** 支持多选*/
         multiple?: boolean,
+        /** 支持清除, 单选模式有效*/
         allowClear?: boolean,
+        /** 是否根据输入项进行筛选，可为一个函数，返回满足要求的 option 即可*/
         filterOption?: boolean | Function,
+        /** 可以把随意输入的条目作为 tag，输入项不需要与下拉选项匹配*/
         tags?: boolean,
+        /** 被选中时调用，参数为选中项的 value 值 */
         onSelect?: (value: any, option: any) => void,
+        /** 取消选中时调用，参数为选中项的 option value 值，仅在 multiple 或 tags 模式下生效*/
         onDeselect?: (value: any, option: any) => void,
+        /** 选中option，或input的value变化(combobox 模式下)时，调用此函数*/
         onChange?: (value: any, label: any) => void,
+        /** 文本框值变化时回调*/
         onSearch?: (value: string) => void,
+        /** 选择框默认文字*/
         placeholder?: string,
+        /** 搜索框默认文字*/
         searchPlaceholder?: string,
+        /** 当下拉列表为空时显示的内容*/
         notFoundContent?: string,
+        /** 下拉菜单和选择器同宽*/
         dropdownMatchSelectWidth?: boolean,
+        /** 搜索时过滤对应的 option 属性，如设置为 children 表示对内嵌内容进行搜索*/
         optionFilterProp?: string,
+        /** 输入框自动提示模式*/
         combobox?: SVGSymbolElement,
+        /** 选择框大小，可选 `large` `small` */
         size?: string,
+        /** 在下拉中显示搜索框*/
         showSearch?: boolean,
+        /** 是否禁用*/
         disabled?: boolean,
         style?: Object
     }
+    /**
+     * #Select
+    类似 Select2 的选择器。
+
+    ## 何时使用
+
+    弹出一个下拉菜单给用户选择操作，用于代替原生的选择器，或者需要一个更优雅的多选器时。*/
     export class Select extends React.Component<SelectProps, {}>{
         static Option: typeof SelectOption
         static OptGroup: typeof SelectOptGroup
@@ -664,20 +1224,39 @@ declare namespace Antd {
 
     // Slider
     interface SliderProps extends React.Props<Slider> {
+        /** 最小值*/
         min?: number,
+        /** 最大值*/
         max?: number,
+        /** 步长，取值必须大于 0，并且可被 (max - min) 整除。当 `marks` 不为空对象时，可以设置 `step` 为 `null`，此时 Slider 的可选值仅有 marks 标出来的部分。*/
         step?: number,
+        /** 分段标记，key 的类型必须为 `Number` 且取值在闭区间 [min, max] 内*/
         marks?: { key: number, value: any },
+        /**  设置当前取值。当 `range` 为 `false` 时，使用 `Number`，否则用 `[Number, Number]`*/
         value?: number | Array<number>,
+        /**  设置当前取值。当 `range` 为 `false` 时，使用 `Number`，否则用 `[Number, Number]`*/
         defaultValue?: number | Array<number>,
+        /** `marks` 不为空对象时有效，值为 true 时表示值为包含关系，false 表示并列*/
         included?: boolean,
+        /** 值为 `true` 时，滑块为禁用状态*/
         disabled?: boolean,
+        /** 当 `range` 为 `true` 时，该属性可以设置是否允许两个滑块交换位置。*/
         allowCross?: boolean,
+        /** 当 Slider 的值发生改变时，会触发 onChange 事件，并把改变后的值作为参数传入。*/
         onChange?: Function,
+        /** 与 `onmouseup` 触发时机一致，把当前值作为参数传入。*/
         onAfterChange?: Function,
+        /** Slider 会把当前值传给 `tipFormatter`，并在 Tooltip 中显示 `tipFormatter` 的返回值，若为 null，则隐藏 Tooltip。*/
         tipFormatter?: Function | any,
         range?: boolean
     }
+    /**
+     * #Slider
+    滑动型输入器，展示当前值和可选范围。
+
+    ## 何时使用
+
+    当用户需要在数值区间/自定义区间内进行选择时，可为连续或离散值。*/
     export class Slider extends React.Component<SliderProps, {}>{ }
 
 
@@ -685,9 +1264,19 @@ declare namespace Antd {
 
     // Spin
     interface SpinProps extends React.Props<Spin> {
+        /** spin组件中点的大小，可选值为 small default large*/
         size?: string,
+        /** 用于内嵌其他组件的模式，可以关闭 loading 效果*/
         spining?: boolean
     }
+    /**
+     * #Spin
+    用于页面和区块的加载中状态。
+
+    ## 何时使用
+
+    页面局部处于等待异步数据或正在渲染过程时，合适的加载动效会有效缓解用户的焦虑。
+    */
     export class Spin extends React.Component<SpinProps, {}>{ }
 
 
@@ -698,20 +1287,35 @@ declare namespace Antd {
         wait, process, finish
     }
     interface StepProps extends React.Props<Step> {
+        /** 可选参数，指定状态。当不配置该属性时，会使用父Steps元素的current来自动指定状态。*/
         status?: StepStatus | string,
+        /** 必要参数，标题。*/
         title: string | React.ReactNode,
+        /**  可选参数，步骤的详情描述。*/
         description?: string | React.ReactNode,
+        /** 可选参数，步骤的Icon。如果不指定，则使用默认的样式。*/
         icon?: string | React.ReactNode
     }
     export class Step extends React.Component<StepProps, {}>{ }
 
     interface StepsProps extends React.Props<Steps> {
+        /** 可选参数，指定当前处理正在执行状态的步骤，从0开始记数。在子Step元素中，可以通过status属性覆盖状态。*/
         current?: number,
+        /** 可选参数，指定大小（目前只支持普通和迷你两种大小）。 small, default */
         size?: string,
+        /** 可选参数，指定步骤条方向（目前支持水平和竖直两种方向，默认水平方向）。*/
         direction?: string,
+        /** 可选参数，指定步骤的详细描述文字的最大宽度。*/
         maxDescriptionWidth?: number
 
     }
+    /**
+     * #Steps
+    引导用户按照流程完成任务的导航条。
+
+    ## 何时使用
+
+    当任务复杂或者存在先后关系时，将其分解成一系列步骤，从而简化任务。*/
     export class Steps extends React.Component<StepsProps, {}>{
         static Step: typeof Step
     }
@@ -720,13 +1324,28 @@ declare namespace Antd {
 
     // Switch
     interface SwitchProps extends React.Props<Switch> {
+        /** 指定当前是否选中*/
         checked?: boolean,
+        /** 初始是否选中*/
         defaultChecked?: boolean,
+        /** 变化时回调函数*/
         onChange?: (checked: boolean) => void,
+        /** 选中时的内容*/
         checkedChildren?: React.ReactNode,
+        /** 非选中时的内容*/
         unCheckedChildren?: React.ReactNode,
+        /** 开关大小*/
         size?: string
     }
+    /**
+     * #Switch
+    开关选择器。
+
+    ## 何时使用
+
+    - 需要表示开关状态/两种状态之间的切换时；
+    - 和 `checkbox `的区别是，切换 `switch` 会直接触发状态改变，而 `checkbox` 一般用于状态标记，需要和提交操作配合。
+    */
     export class Switch extends React.Component<SwitchProps, {}>{ }
 
 
@@ -738,7 +1357,7 @@ declare namespace Antd {
         radio
     }
     type SelectedRowKeys = Array<any>
-    type RowSelection = {
+    interface RowSelection {
         type?: RowSelectionType | string,
         selectedRowKeys?: SelectedRowKeys,
         onChange?: (selectedRowKeys: SelectedRowKeys, selectedRows: any) => void,
@@ -746,45 +1365,82 @@ declare namespace Antd {
         onSelect?: (record: any, selected: any, selectedRows: any) => void,
         onSelectAll?: (rselectedecord: any, selectedRows: any, changeRows: any) => void
     }
-    type Columns = {
+    interface Columns {
+        /** React 需要的 key，建议设置*/
         key?: string,
+        /** 列头显示文字*/
         title?: string | React.ReactNode,
+        /** 列数据在数据项中对应的 key*/
         dataIndex?: string,
+        /** 生成复杂数据的渲染函数，参数分别为当前列的值，当前列数据，列索引，@return里面可以设置表格[行/列合并](#demo-colspan-rowspan)*/
         render?: (text?: any, record?: any, index?: number) => React.ReactNode,
+        /** 表头的筛选菜单项*/
         filters?: Array<any>,
+        /** 本地模式下，确定筛选的运行函数*/
         onFilter?: Function,
+        /** 是否多选*/
         filterMultiple?: boolean,
+        /** 排序函数，本地排序使用一个函数，需要服务端排序可设为 true */
         sorter?: boolean | Function,
+        /** 表头列合并,设置为 0 时，不渲染*/
         colSpan?: number,
+        /** 列宽度*/
         width?: string | number,
+        /** 列的 className*/
         className?: string
     }
     interface TableProps extends React.Props<Table> {
+        /** 列表项是否可选择*/
         rowSelection?: RowSelection,
+        /** 分页器*/
         pagination?: Object,
+        /** 正常或迷你类型 : `default` or `small` */
         size?: string,
+        /** 数据数组*/
         dataSource: Array<any>,
+        /** 表格列的配置描述*/
         columns: Columns,
+        /** 表格行 key 的取值*/
         rowKey?: (record: any, index: number) => string,
+        /** 额外的展开行*/
         expandedRowRender?: Function,
+        /** 默认展开的行*/
         defaultExpandedRowKeys?: Array<string>,
+        /** 分页、排序、筛选变化时触发*/
         onChange?: (pagination: Object, filters: any, sorter: any) => void,
+        /** 页面是否加载中*/
         loading?: boolean,
+        /** 默认文案设置，目前包括排序、过滤、空数据文案: `{ filterConfirm: '确定', filterReset: '重置', emptyText: '暂无数据' }` */
         locale?: Object,
+        /** 展示树形数据时，每层缩进的宽度，以 px 为单位*/
         indentSize?: number,
+        /** 处理行点击事件*/
         onRowClick?: (record: any, index: number) => void,
+        /** 是否固定表头*/
         useFixedHeader?: boolean,
+        /** 是否展示外边框和列边框*/
         bordered?: boolean,
+        /** 是否显示表头*/
         showHeader?: boolean,
+        /** 表格底部自定义渲染函数*/
         footer?: (currentPageData: Object) => void
 
     }
+    /**
+     * #Table
+    展示行列数据。
+
+    ## 何时使用
+
+    - 当有大量结构化的数据需要展现时；
+    - 当需要对数据进行排序、搜索、分页、自定义操作等复杂行为时。*/
     export class Table extends React.Component<TableProps, {}>{ }
 
 
 
     // Tabs
     interface TabPaneProps extends React.Props<TabPane> {
+        /** 选项卡头显示文字*/
         tab: React.ReactNode | string
     }
     export class TabPane extends React.Component<TabPaneProps, {}>{ }
@@ -799,15 +1455,36 @@ declare namespace Antd {
         left
     }
     interface TabsProps extends React.Props<Tabs> {
+        /** 当前激活 tab 面板的 key    */
         activeKey?: string,
+        /** 初始化选中面板的 key，如果没有设置 activeKey*/
         defaultActiveKey?: string,
+        /** 切换面板的回调*/
         onChange?: Function,
+        /** tab 被点击的回调 */
         onTabClick?: Function,
+        /** tab bar 上额外的元素  */
         tabBarExtraContent?: React.ReactNode,
+        /** 页签的基本样式，可选 `line`、`card` `editable-card` 类型*/
         type?: TabsType | string,
+        /** 页签位置，可选值有 `top` `right` `bottom` `left`*/
         tabPosition?: TabsPosition | string,
+        /** 新增和删除页签的回调，在 `type="editable-card"` 时有效*/
         onEdit?: (targetKey: string, action: any) => void
     }
+    /**
+     * #Tabs
+    选项卡切换组件。
+
+    ## 何时使用
+    
+    提供平级的区域将大块内容进行收纳和展现，保持界面整洁。
+    
+    Ant Design 依次提供了三级选项卡，分别用于不同的场景。
+    
+    - 卡片式的页签，提供可关闭的样式，常用于容器顶部。
+    - 标准线条式页签，用于容器内部的主功能切换，这是最常用的 Tabs。
+    - [RadioButton](/components/radio/#demo-radiobutton) 可作为更次级的页签来使用。*/
     export class Tabs extends React.Component<TabsProps, {}>{
         static TabPane: typeof TabPane
     }
@@ -817,11 +1494,23 @@ declare namespace Antd {
 
     // Tag
     interface TagProps extends React.Props<Tag> {
+        /** 标签是否可以关闭*/
         closable?: boolean,
+        /** 关闭时的回调*/
         onClose?: Function,
+        /** 动画关闭后的回调*/
         afterClose?: Function,
+        /** 标签的色彩*/
         color?: string
     }
+    /**
+     * #Tag
+    进行标记和分类的小标签。
+    
+    ## 何时使用
+    
+    - 用于标记事物的属性和维度。
+    - 进行分类。*/
     export class Tag extends React.Component<TagProps, {}>{ }
 
 
@@ -831,20 +1520,39 @@ declare namespace Antd {
 
     // TimePicker
     interface TimePickerProps extends React.Props<TimePicker> {
-
+        /** 默认时间*/
         value?: string | Date,
+        /** 初始默认时间*/
         defaultValue?: string | Date,
+        /** 展示的时间格式 : "HH:mm:ss"、"HH:mm"、"mm:ss" */
         format?: string,
+        /** 时间发生变化的回调*/
         onChange?: (Date: Date) => void,
+        /** 禁用全部操作*/
         disabled?: boolean,
+        /** 没有值的时候显示的内容*/
         placeholder?: string,
+        /** 国际化配置*/
         locale?: Object,
+        /** 隐藏禁止选择的选项*/
         hideDisabledOptions?: boolean,
+        /** 禁止选择部分小时选项*/
         disabledHours?: Function,
+        /** 禁止选择部分分钟选项*/
         disabledMinutes?: Function,
+        /** 禁止选择部分秒选项*/
         disabledSeconds?: Function
 
     }
+    /**
+     * #TimePicker
+    输入或选择时间的控件。
+    
+    何时使用
+    --------
+    
+    当用户需要输入一个时间，可以点击标准输入框，弹出时间面板进行选择。
+    */
     export class TimePicker extends React.Component<TimePickerProps, {}>{ }
 
 
@@ -852,13 +1560,23 @@ declare namespace Antd {
 
     // Timeline
     interface TimeLineItemProps extends React.Props<TimeLineItem> {
+        /** 指定圆圈颜色。*/
         color?: string
     }
     export class TimeLineItem extends React.Component<TimeLineItemProps, {}>{ }
 
     interface TimelineProps extends React.Props<Timeline> {
+        /** 指定最后一个幽灵节点是否存在或内容*/
         pending?: boolean | React.ReactNode
     }
+    /**
+     * #Timeline
+    垂直展示的时间流信息。
+    
+    ## 何时使用
+    
+    - 当有一系列信息需要从上至下按时间排列时；
+    - 需要有一条时间轴进行视觉上的串联时；*/
     export class Timeline extends React.Component<TimelineProps, {}>{
         static Item: typeof TimeLineItem
     }
@@ -868,9 +1586,20 @@ declare namespace Antd {
     // Tooltip
 
     interface TooltipProps extends React.Props<Tooltip> {
+        /** 气泡框位置，可选 `top` `left` `right` `bottom` `topLeft` `topRight` `bottomLeft` `bottomRight` `leftTop` `leftBottom` `rightTop` `rightBottom`*/
         placement?: PopoverPlacement | string,
+        /** 提示文字*/
         title?: string | React.ReactNode
     }
+    /**
+     * #Tooltip
+    简单的文字提示气泡框。
+    
+    ## 何时使用
+    
+    鼠标移入则显示提示，移出消失，气泡浮层不承载复杂文本和操作。
+    
+    可用来代替系统默认的 `title` 提示，提供一个`按钮/文字/操作`的文案解释。*/
     export class Tooltip extends React.Component<TooltipProps, {}>{ }
 
 
@@ -879,19 +1608,39 @@ declare namespace Antd {
 
     // Transfer
     interface TransferProps extends React.Props<Transfer> {
+        /** 数据源*/
         dataSource: Array<any>,
+        /** 每行数据渲染函数*/
         render?: (record: Object) => any,
+        /** 显示在右侧框数据的key集合*/
         targetKeys: Array<string>,
+        /** 变化时回调函数*/
         onChange?: (targetKeys: any, direction: string, moveKeys: any) => void,
+        /** 两个穿梭框的自定义样式*/
         listStyle?: Object,
+        /** 自定义类*/
         className?: string,
+        /** 标题集合,顺序从左至右*/
         titles?: Array<string>,
+        /** 操作文案集合,顺序从上至下*/
         operations?: Array<string>,
+        /** 是否显示搜索框*/
         showSearch?: boolean,
+        /** 搜索框的默认值*/
         searchPlaceholder?: string,
+        /** 当列表为空时显示的内容*/
         notFoundContent?: React.ReactNode | string
+        /** 底部渲染函数*/
         footer?: (props: any) => any
     }
+    /**
+     * #Transfer
+    双栏穿梭选择框。
+    
+    ## 何时使用
+    
+    用直观的方式在两栏中移动元素，完成选择行为。
+    */
     export class Transfer extends React.Component<TransferProps, {}>{ }
 
 
@@ -911,28 +1660,53 @@ declare namespace Antd {
     interface TreeProps extends React.Props<Tree> {
         showLine?: boolean,
         className?: string,
+        /** 是否支持多选*/
         multiple?: boolean,
+        /** 是否支持选中*/
         checkable?: boolean,
+        /** 默认展开所有树节点*/
         defaultExpandAll?: boolean,
+        /** 默认展开指定的树节点*/
         defaultExpandedKeys?: Array<string>,
+        /** （受控）展开指定的树节点*/
         expandedKeys?: Array<string>,
+        /** （受控）选中复选框的树节点*/
         checkedKeys?: Array<string>,
+        /** 默认选中复选框的树节点*/
         defaultCheckedKeys?: Array<string>,
+        /** （受控）设置选中的树节点*/
         selectedKeys?: Array<string>,
+        /** 默认选中的树节点*/
         defaultSelectedKeys?: Array<string>,
+        /** 展开/收起节点时触发 */
         onExpand?: (node: any, expanded: any, expandedKeys: any) => void,
+        /** 点击复选框触发*/
         onCheck?: (checkedKeys: any, e: { checked: boolean, checkedNodes: any, node: any, event: Event }) => void,
+        /** 点击树节点触发*/
         onSelect?: (selectedKeys: any, e: { selected: boolean, selectedNodes: any, node: any, event: Event }) => void,
+        /** filter some treeNodes as you need. it should return true */
         filterTreeNode?: (node: any) => boolean,
+        /** 异步加载数据*/
         loadData?: (node: any) => void,
+        /** 响应右键点击*/
         onRightClick?: (options: { event: Event, node: any }) => void,
+        /** 设置节点可拖拽（IE>8）*/
         draggable?: boolean,
+        /** 开始拖拽时调用*/
         onDragStart?: (options: { event: Event, node: any }) => void,
+        /** dragenter 触发时调用*/
         onDragEnter?: (options: { event: Event, node: any, expandedKeys: any }) => void,
+        /** dragover 触发时调用 */
         onDragOver?: (options: { event: Event, node: any }) => void,
+        /** dragleave 触发时调用*/
         onDragLeave?: (options: { event: Event, node: any }) => void,
+        /** drop 触发时调用*/
         onDrop?: (options: { event: Event, node: any, dragNode: any, dragNodesKeys: any }) => void,
     }
+    /**
+     * #Tree
+     * 文件夹、组织架构、生物分类、国家地区等等，世间万物的大多数结构都是树形结构。使用`树控件`可以完整展现其中的层级关系，并具有展开收起选择等交互功能。
+    */
     export class Tree extends React.Component<TreeProps, {}>{
         static TreeNode: typeof TreeNode
     }
@@ -944,9 +1718,13 @@ declare namespace Antd {
     // TreeSelect
     interface TreeSelectTreeNodeProps extends React.Props<TreeSelectTreeNode> {
         disabled?: boolean,
+        /** 此项必须设置（其值在整个树范围内唯一）*/
         key: string,
+        /** 默认根据此属性值进行筛选*/
         value?: string,
+        /** 树节点显示的内容*/
         title?: React.ReactNode | string,
+        /** 是否是叶子节点*/
         isLeaf?: boolean
     }
     export class TreeSelectTreeNode extends React.Component<TreeSelectTreeNodeProps, {}>{ }
@@ -954,30 +1732,61 @@ declare namespace Antd {
     type TreeData = Array<{ value: any, label: string, children: TreeData }>
     interface TreeSelectProps extends React.Props<TreeSelect> {
         style?: Object,
+        /** 指定当前选中的条目*/
         value?: string | Array<any>,
+        /** 指定默认选中的条目*/
         defaultValue?: string | Array<any>,
+        /** 支持多选*/
         multiple?: boolean,
+        /** 可以把随意输入的条目作为 tag，输入项不需要与下拉选项匹配*/
         tags?: boolean,
+        /** 被选中时调用，参数为选中项的 value 值*/
         onSelect?: (value: any) => void,
+        /** 选中option，或input的value变化(combobox 模式下)时，调用此函数*/
         onChange?: (value: any, label: any) => void,
+        /** 显示清除按钮*/
         allowClear?: boolean,
+        /** 文本框值变化时回调*/
         onSearch?: (value: any) => void,
+        /** 选择框默认文字*/
         placeholder?: string,
+        /** 搜索框默认文字*/
         searchPlaceholder?: string,
+        /** 下拉菜单的样式*/
         dropdownStyle?: Object,
+        /** 下拉菜单和选择器同宽*/
         dropdownMatchSelectWidth?: boolean,
+        /** 输入框自动提示模式*/
         combobox?: boolean,
+        /** 选择框大小，可选 `large` `small`*/
         size?: string,
+        /** 在下拉中显示搜索框*/
         showSearch?: boolean,
+        /** 是否禁用*/
         disabled?: boolean,
+        /** 默认展开所有树节点*/
         treeDefaultExpandAll?: boolean,
+        /** 显示checkbox*/
         treeCheckable?: boolean,
-        filterTreeNode?: (treeNode: any) => void,
+        /** 是否根据输入项进行筛选，返回值true*/
+        filterTreeNode?: (treeNode: any) => boolean,
+        /**  输入项过滤对应的 treeNode 属性*/
         treeNodeFilterProp?: string,
+        /** 作为显示的prop设置*/
         treeNodeLabelProp?: string,
+        /** treeNodes数据，如果设置则不需要手动构造TreeNode节点（如果value在整个树范围内不唯一，需要设置`key`其值为整个树范围内的唯一id*/
         treeData?: TreeData,
+        /** 异步加载数据*/
         loadData?: (node: any) => void
     }
+    /**
+     * #TreeSelect
+    树型选择控件。
+    
+    ## 何时使用
+    
+    类似 Select 的选择控件，可选择的数据结构是一个树形结构时，可以使用 TreeSelect，例如公司层级、学科系统、分类目录等等。
+    */
     export class TreeSelect extends React.Component<TreeSelectProps, {}>{
         static TreeNode: typeof TreeSelectTreeNode
     }
@@ -989,19 +1798,41 @@ declare namespace Antd {
 
     // Upload
     interface UploadProps extends React.Props<Upload> {
+        /** 可选参数, 上传的文件  */
         name?: string,
+        /** 必选参数, 上传的地址   */
         action: string,
+        /** 可选参数, 上传所需参数    */
         data?: Object,
+        /** 可选参数, 设置上传的请求头部，IE10 以上有效*/
         headers?: Object,
+        /** 可选参数, 是否展示 uploadList, 默认开启     */
         showUploadList?: boolean,
+        /** 可选参数, 是否支持多选文件，`ie10+` 支持。开启后按住 ctrl 可选择多个文件。*/
         multiple?: boolean,
+        /** 可选参数, 接受上传的文件类型, 详见 input accept Attribute */
         accept?: string,
+        /** 可选参数, 上传文件之前的钩子，参数为上传的文件，若返回 `false` 或者 Promise 则停止上传。**注意：该方法不支持老 IE**。*/
         beforeUpload?: Function,
+        /** 可选参数, 上传文件改变时的状态，详见 onChange   */
         onChange?: (info: Object) => void,
+        /** 上传列表的内建样式，支持两种基本样式 `text` or `picture`   */
         listType?: string,
+        /** 自定义类名*/
         className?: string
 
     }
+    /**
+     * #Upload
+    文件选择上传和拖拽上传控件。
+    
+    ## 何时使用
+    
+    上传是将信息（网页、文字、图片、视频等）通过网页或者上传工具发布到远程服务器上的过程。
+    
+    - 当需要上传一个或一些文件时。
+    - 当需要展现上传的进度时。
+    - 当需要使用拖拽交互时。*/
     export class Upload extends React.Component<UploadProps, {}>{ }
 
 
diff --git a/async/async.d.ts b/async/async.d.ts
index 543b3751d..b266786b6 100644
--- a/async/async.d.ts
+++ b/async/async.d.ts
@@ -127,8 +127,8 @@ interface Async {
     doDuring(fn: AsyncVoidFunction, test: (testCallback: (error: Error, truth: boolean) => void) => void, callback: (err: any) => void): void;
     forever(next: (errCallback : (err: Error) => void) => void, errBack: (err: Error) => void) : void;
     waterfall(tasks: Function[], callback?: (err: Error, results?: any) => void): void;
-    compose(...fns: Function[]): void;
-    seq(...fns: Function[]): void;
+    compose(...fns: Function[]): Function;
+    seq(...fns: Function[]): Function;
     applyEach(fns: Function[], argsAndCallback: any[]): void;           // applyEach(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
     applyEachSeries(fns: Function[], argsAndCallback: any[]): void;     // applyEachSeries(fns, args..., callback). TS does not support ... for a middle argument. Callback is optional.
     queue<T>(worker: AsyncWorker<T>, concurrency?: number): AsyncQueue<T>;
diff --git a/bookshelf/bookshelf.d.ts b/bookshelf/bookshelf.d.ts
index 153208584..ca93456bb 100644
--- a/bookshelf/bookshelf.d.ts
+++ b/bookshelf/bookshelf.d.ts
@@ -88,7 +88,7 @@ declare module 'bookshelf' {
 			belongsTo<R extends Model<any>>(target : {new(...args : any[]) : R}, foreignKey? : string) : R;
 			belongsToMany<R extends Model<any>>(target : {new(...args : any[]) : R}, table? : string, foreignKey? : string, otherKey? : string) : Collection<R>;
 			count(column? : string, options? : SyncOptions) : Promise<number>;
-			destroy(options : SyncOptions) : Promise<T>;
+			destroy(options? : SyncOptions) : Promise<T>;
 			fetch(options? : FetchOptions) : Promise<T>;
 			fetchAll(options? : FetchAllOptions) : Promise<Collection<T>>;
 			hasMany<R extends Model<any>>(target : {new(...args : any[]) : R}, foreignKey? : string) : Collection<R>;
diff --git a/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-3.0.0.d.ts b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-3.0.0.d.ts
new file mode 100644
index 000000000..1512f719b
--- /dev/null
+++ b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-3.0.0.d.ts
@@ -0,0 +1,113 @@
+// Type definitions for Bootstrap datetimepicker v3 
+// Project: http://eonasdan.github.io/bootstrap-datetimepicker
+// Definitions by: Jesica N. Fera <https://github.com/bayitajesi>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+/**
+ * bootstrap-datetimepicker.js 3.0.0 Copyright (c) 2014 Jonathan Peterson
+ * Available via the MIT license.
+ * see: http://eonasdan.github.io/bootstrap-datetimepicker or https://github.com/Eonasdan/bootstrap-datetimepicker for details.
+ */
+
+/// <reference path="../jquery/jquery.d.ts"/>
+/// <reference path="../moment/moment.d.ts"/>
+
+declare module BootstrapV3DatetimePicker {
+    interface DatetimepickerChangeEventObject extends DatetimepickerEventObject {
+        oldDate: moment.Moment;
+    }
+
+    interface DatetimepickerEventObject extends JQueryEventObject {
+        date: moment.Moment;
+    }
+
+    interface DatetimepickerIcons {
+        time?: string;
+        date?: string;
+        up?: string;
+        down?: string;
+    }
+
+    interface DatetimepickerOptions {
+        pickDate?: boolean;
+        pickTime?: boolean;
+        useMinutes?: boolean;
+        useSeconds?: boolean;
+        useCurrent?: boolean;
+        minuteStepping?: number;
+        minDate?: moment.Moment | Date | string;
+        maxDate?: moment.Moment | Date | string;
+        showToday?: boolean;
+        collapse?: boolean;
+        language?: string;
+        defaultDate?: moment.Moment | Date | string;
+        disabledDates?: Array<moment.Moment | Date | string>;
+        enabledDates?: Array<moment.Moment | Date | string>;
+        icons?: DatetimepickerIcons;
+        useStrict?: boolean;
+        direction?: string;
+        sideBySide?: boolean;
+        daysOfWeekDisabled?: Array<number>;
+        calendarWeeks?: boolean;
+        format?: string | boolean;
+        locale?: string;
+        showTodayButton?: boolean;
+        viewMode?: string;
+        inline?: boolean;
+        toolbarPlacement?: string;
+        showClear?: boolean;
+        ignoreReadonly?: boolean;
+    }
+
+    interface Datetimepicker {
+        date(date: moment.Moment | Date | string): void;
+        date(): moment.Moment;
+        minDate(date: moment.Moment | Date | string): void;
+        minDate(): moment.Moment | boolean;
+        maxDate(date: moment.Moment | Date | string): void;
+        maxDate(): moment.Moment | boolean;
+        show(): void;
+        disable(): void;
+        enable(): void;
+        destroy(): void;
+        toggle(): void;
+    }
+
+}
+
+
+interface JQuery {
+
+    datetimepicker(): JQuery;
+    datetimepicker(options: BootstrapV3DatetimePicker.DatetimepickerOptions): JQuery;
+
+    off(events: "dp.change", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+    off(events: "dp.change", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+
+    on(events: "dp.change", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+    on(events: "dp.change", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+    on(events: 'dp.change', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+
+    off(events: "dp.show", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    off(events: "dp.show", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    on(events: "dp.show", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: "dp.show", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: 'dp.show', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    off(events: "dp.hide", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    off(events: "dp.hide", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    on(events: "dp.hide", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: "dp.hide", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: 'dp.hide', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    off(events: "dp.error", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    off(events: "dp.error", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    on(events: "dp.error", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: "dp.error", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: 'dp.error', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+
+    data(key: 'DateTimePicker'): BootstrapV3DatetimePicker.Datetimepicker;
+}
diff --git a/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-tests.ts b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-tests.ts
index e17b7b10c..137e84720 100644
--- a/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-tests.ts
+++ b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker-tests.ts
@@ -3,12 +3,6 @@
 
 function test_cases() {
     $('#datetimepicker').datetimepicker();
-    $('#datetimepicker').datetimepicker({
-        pickDate: false
-    });
-    $('#datetimepicker').datetimepicker({
-        pickTime: false
-    });
     $('#datetimepicker').datetimepicker({
         minDate: '2012-12-31'
     });
diff --git a/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker.d.ts b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker.d.ts
index eced1096f..a417f1a5b 100644
--- a/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker.d.ts
+++ b/bootstrap.v3.datetimepicker/bootstrap.v3.datetimepicker.d.ts
@@ -1,10 +1,11 @@
-// Type definitions for Bootstrap datetimepicker v3 
+// Type definitions for Bootstrap 3 Datepicker v4.17.37 
 // Project: http://eonasdan.github.io/bootstrap-datetimepicker
-// Definitions by: Jesica N. Fera <https://github.com/bayitajesi>
+// Definitions by: Katona Péter <https://github.com/katonap>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
+// based on the previous version created by Jesica N. Fera <https://github.com/bayitajesi>
 
 /**
- * bootstrap-datetimepicker.js 3.0.0 Copyright (c) 2014 Jonathan Peterson
+ * bootstrap-datetimepicker.js 4.17.37 Copyright (c) 2015 Jonathan Peterson
  * Available via the MIT license.
  * see: http://eonasdan.github.io/bootstrap-datetimepicker or https://github.com/Eonasdan/bootstrap-datetimepicker for details.
  */
@@ -13,101 +14,575 @@
 /// <reference path="../moment/moment.d.ts"/>
 
 declare module BootstrapV3DatetimePicker {
-    interface DatetimepickerChangeEventObject extends DatetimepickerEventObject {
-        oldDate: moment.Moment;
+
+	interface Datetimepicker {
+		/**Clears the datepicker by setting the value to null */
+		clear(): void;
+		/**Returns the component's model current date, a moment object or null if not set. */
+		date(): moment.Moment;
+		/**Takes string, Date, moment, null parameter and sets the components model current moment to it.
+		 * Passing a null value unsets the components model current moment.
+		 * Parsing of the newDate parameter is made using moment library with the options.format and options.useStrict components configuration.
+		 * Throws:
+		 * - TypeError - in case the newDate cannot be parsed
+		 * 
+		 * Emits:
+		 * - dp.change - In case newDate is different from current moment
+		 */
+		date(date: moment.Moment | Date | string): void;
+		/**Destroys the widget and removes all attached event listeners */
+		destroy(): void;
+		/**Disables the input element, the component is attached to, by adding a disabled="true" attribute to it. If the widget was visible before that call it is hidden.
+		 * Emits:
+		 * - dp.hide - if the widget was visible before that call
+		 */
+		disable(): void;
+		/**Enables the input element, the component is attached to, by removing disabled attribute from it. */
+		enable(): void;
+		/**Hides the widget
+		 * Emits:
+		 * - dp.hide - if the widget was visible before that call
+		 */
+		hide(): void;
+		/**Returns the components current options object.
+		 * Note that the changing the values of the returned object does not change the components actual configuration. */
+		options(): DatetimepickerOptions
+		/**Takes an object variable with option key:value properties and configures the component. Use this to update multiple options on the component. */
+		options(options: DatetimepickerOptions): void
+		/**Shows the widget
+		 * Emits:
+		 * - dp.show - if the widget was hidden before that call
+		 * - dp.change - if the widget is opened for the first time and the useCurrent is set to true or to a granularity value and the input element the component is attached to has an empty value
+		 */
+		show(): void;
+		/**Shows or hides the widget
+		 * Emits:
+		 * - dp.hide - if the widget is hidden after the toggle call
+		 * - dp.show - if the widget is show after the toggle call
+		 * - dp.change - if the widget is opened for the first time and the input element is empty and options.useCurrent != false
+		 */
+		toggle(): void;
+
+		////////////////////////////////////////////////////////////////////////////////////////////////////
+		//// Below are the getters/setters for the properties of the 'options(): DatetimepickerOptions' ////
+		////////////////////////////////////////////////////////////////////////////////////////////////////
+
+		/**Returns the options.allowInputToggle option. */
+		allowInputToggle(): boolean;
+		/**If true, the picker will show on textbox focus and icon click when used in a button group */
+		allowInputToggle(value: boolean): void;
+		/**Returns the current options.calendarWeeks option configuration */
+		calendarWeeks(): boolean;
+		/**Set if the week numbers will appear to the left on the days view */
+		calendarWeeks(value: boolean): void;
+		/**Returns the options.collapse option configuration */
+		collapse(): boolean;
+		/**If set to false the picker will display similar to sideBySide except vertical. */
+		collapse(value: boolean): void;
+		/**Returns the options.daysOfWeekDisabled configuration
+		 * IMPORTANT! Throws exception if not set explicitly https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1459
+		*/
+		daysOfWeekDisabled(): Array<number>;
+		/**Takes an [ Number:0 to 6 ] and disallow the user to select weekdays that exist in this array.
+		 * This has lower priority over the options.minDate, options.maxDate, options.disabledDates and options.enabledDates configuration settings.
+		 * Emits:
+		 * - dp.change - if the currently selected moment falls in the values passed on the daysOfWeek parameter.
+		 * - dp.error - if the currently selected moment falls in the values passed on the daysOfWeek parameter.
+		 */
+		daysOfWeekDisabled(days: Array<number>): void;
+		/**Returns the options.dayViewHeaderFormat option. */
+		dayViewHeaderFormat(): string;
+		/**Used to customize the header of the day view. */
+		dayViewHeaderFormat(value: string): void;
+		/**Returns a moment with the options.defaultDate option configuration or false if not set */
+		defaultDate(): moment.Moment | boolean;
+		/**Will set the picker's inital date.
+		 * If a boolean:false value is passed the options.defaultDate parameter is cleared.
+		 * Throws:
+		 * - TypeError - if the provided date doesn't pass validation, including disabledDates, enabledDates, minDate, maxDate, and daysOfWeekDisabled
+		 * - TypeError - if the provided date cannot be parsed by momentjs
+		 */
+		defaultDate(date: string | Date | moment.Moment | boolean): void;
+		/**Returns the options.disabledDates option.
+		 * NOTES: probably should be: disabledDates(): boolean | Array<moment.Moment>; see: DatetimepickerOptions
+		*/
+		disabledDates(): boolean | any;
+		/**Takes an array of values and disallows the user to select those days.
+		 * Setting this takes precedence over options.minDate, options.maxDate configuration.
+		 * Also calling this function removes the configuration of options.enabledDates if such exist.
+		 * Note: These values are matched with Day granularity.
+		 */
+		disabledDates(dates: boolean | Array<string | Date | moment.Moment>): void;
+		/**Returns the options.disabledHours option.
+		 * NOTES: probably should be: disabledHours(): boolean | Array<number>; see: DatetimepickerOptions
+		*/
+		disabledHours(): boolean | any;
+		/**Must be in 24 hour format. Will disallow hour selections (much like disabledTimeIntervals) but will affect all days.
+		 * Like en/disabledDates, the en/disabledHours options are mutually exclusive and will reset one of the options back to false. */
+		disabledHours(value: boolean | Array<number>): void;
+		/**Returns the options.disabledTimeIntervals option, or... not exactly
+		 * IMPORTANT! Creates an object from the options.disabledTimeIntervals with the keys being numbers, the values being the moment arrays.
+		 * eg { "0": [<moment.Moment1>, <moment.Moment2>], "1": [...] }
+		 * https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1498
+		 */
+		disabledTimeIntervals(): boolean | Array<Array<moment.Moment>>;
+		/**Disables time selection between the given moments
+		 * eg: [[moment({ h: 0 }), moment({ h: 8 })], [moment({ h: 18 }), moment({ h: 24 })]]
+		 */
+		disabledTimeIntervals(value: boolean | Array<Array<moment.Moment>>): void;
+		/**Returns the options.enabledDates option
+		 * NOTES: probably should be: enabledDates(): boolean | Array<moment.Moment>; see: DatetimepickerOptions
+		*/
+		enabledDates(): boolean | any;
+		/**Takes an array of values and allows the user to select only from those days.
+		 * Setting this takes precedence over options.minDate, options.maxDate configuration.
+		 * Also calling this function removes the configuration of options.disabledDates if such exist.
+		 * Note: These values are matched with Day granularity.
+		 */
+		enabledDates(dates: boolean | Array<string | Date | moment.Moment>): void;
+		/**Returns the options.enabledHours option.
+		 * NOTES: probably should be: enabledHours(): boolean | Array<number>; see: DatetimepickerOptions
+		*/
+		enabledHours(): boolean | any;
+		/**Must be in 24 hour format. Will allow hour selections (much like enabledTimeIntervals) but will affect all days.
+		 * Like en/disabledDates, the en/disabledHours options are mutually exclusive and will reset one of the options back to false. */
+		enabledHours(value: boolean | Array<number>): void;
+		/**Returns a boolean or array with the options.extraFormats option configuration */
+		extraFormats(): boolean | Array<string>;
+		/**Takes an array of valid input moment format options, or boolean:false */
+		extraFormats(formats: boolean | Array<string>): void;
+		/**Returns the options.focusOnShow option. */
+		focusOnShow(): boolean;
+		/**If false, the textbox will not be given focus when the picker is shown */
+		focusOnShow(value: boolean): void;
+		/**Returns the component's options.format string */
+		format(): boolean | string;
+		/**Takes a moment.js format string and sets the components options.format.
+		 * This is used for displaying and also for parsing input strings either from the input element the component is attached to or the date() function.
+		 * The parameter can also be a boolean:false in which case the format is set to the locale's L LT.
+		 * Note: this is also used to determine if the TimePicker sub component will display the hours in 12 or 24 format. (if "a" or "h" exists in the passed string then a 12 hour mode is set)
+		 */
+		format(format: boolean | string): void;
+		/**Returns options.icons */
+		icons(): Icons;
+		/**Takes an Object of strings.
+		 * Throws:
+		 * - TypeError - if icons parameter is not an Object
+		 */
+		icons(icons: Icons): void;
+		/**Returns the options.ignoreReadonly option. */
+		ignoreReadonly(): boolean;
+		/**Set this to true to allow the picker to be used even if the input field is readonly. This will not bypass the disabled property */
+		ignoreReadonly(value: boolean): void;
+		/**Returns the options.inline option. */
+		inline(): boolean;
+		/**Used to customize the header of the day view. */
+		inline(value: boolean): void;
+		/**Returns the options.keepInvalid option. */
+		keepInvalid(): boolean;
+		/**If true, invalid dates will not be reverted to a previous selection or changed. */
+		keepInvalid(value: boolean): void;
+		/**Returns a string variable with the currently set options.keyBinds option. */
+		keyBinds(): any;
+		/**Allows for several keyBinding functions to be specified for ease of access or accessibility. For defaults see {@link http://eonasdan.github.io/bootstrap-datetimepicker/Options/#keybinds}.
+		*/
+		keyBinds(value: any): void;
+		/**Returns the currently set locale of the options.locale */
+		locale(): string;
+		/**Takes a string of any valid moment locale e.g. de for German.
+		 * Throws:
+		 * - TypeError - if the locale is not loaded via a separate script or moment-with-locale
+		 */
+		locale(newLocale: string): void;
+		/**Returns the currently set moment of the options.maxDate or false if not set */
+		maxDate(): moment.Moment | boolean;
+		/**Takes a parameter and disallows the user to select a moment that is after that moment.
+		 * If a boolean:false value is passed options.maxDate is cleared and there is no restriction to the maximum moment the user can select.
+		 * Note: If the parameter is before the currently selected moment the currently selected moment changes to maxDate
+		 * Throws:
+		 * - TypeError - if the parameter cannot be parsed using the options.format and options.useStrict configuration settings
+		 * - TypeError - if the parameter is before options.minDate
+		 * 
+		 * Emits:
+		 * - dp.change - if the new maxDate is after currently selected moment
+		 * - dp.error - if the new maxDate is after currently selected moment
+		 */
+		maxDate(date: moment.Moment | Date | string | boolean): void;
+		/**Returns the currently set moment of the options.minDate or false if not set */
+		minDate(): moment.Moment | boolean;
+		/**Takes a parameter and disallows the user to select a moment that is before that moment.
+		 * If a boolean:false value is passed the options.minDate parameter is cleared and there is no restriction to the miminum moment the user can select.
+		 * Note: If the parameter is after the currently selected moment the currently selected moment changes to minDate parameter
+		 * Throws:
+		 * - TypeError - if the parameter cannot be parsed using the options.format and options.useStrict configuration settings
+		 * - TypeError - if the parameter is after options.maxDate
+		 * 
+		 * Emits:
+		 * - dp.change - if the new minDate is after currently selected moment
+		 * - dp.error - if the new minDate is after currently selected moment
+		 */
+		minDate(date: moment.Moment | Date | string | boolean): void;
+		/**Returns the options.parseInputDate option */
+		parseInputDate(): Function;
+		/**Allows custom input formatting For example: the user can enter "yesterday"" or "30 days ago".
+		 * {@link http://eonasdan.github.io/bootstrap-datetimepicker/Functions/#parseinputdate}
+		 */
+		parseInputDate(value: (input: string) => moment.Moment): void;
+		/**Returns the options.showClear option. */
+		showClear(): boolean;
+		/**Set if the clear date button will appear on the widget */
+		showClear(value: boolean): void;
+		/**Returns the options.showClose option. */
+		showClose(): boolean;
+		/**If true, an icon will be displayed on the toolbar that will hide the picker */
+		showClose(value: boolean): void;
+		/**Returns the options.showTodayButton option. */
+		showTodayButton(): boolean;
+		/**Set if the Today button will appear on the widget */
+		showTodayButton(value: boolean): void;
+		/**Returns a boolean of the options.sideBySide. */
+		sideBySide(): boolean;
+		/**If sideBySide is true and the time picker is used, both components will display side by side instead of collapsing. */
+		sideBySide(value: boolean): void;
+		/**Returns a number with the options.stepping option configuration */
+		stepping(): number;
+		/**This will be the amount the up/down arrows move the minute value with a time picker. */
+		stepping(step: number): void;
+		/**Returns the options.toolbarplacement option. */
+		toolbarPlacement(): string;
+		/**Changes the placement of the toolbar where the today, clear, component switch icon are located.
+		 * See valid values at DatetimepickerOptions.toolbarplacement
+		 * Throws:
+		 * - TypeError if the parameter is not a valid value
+		 */
+		toolbarPlacement(value: string): void;
+		/**Returns the options.tooltips option */
+		tooltips(): Tooltips;
+		/**Sets the tooltips for icons.
+		 * Throws:
+		 * - TypeError - if tooltips parameter is not an Object
+		 */
+		tooltips(value: Tooltips): void;
+		/**Returns the options.useCurrent option configuration */
+		useCurrent(): boolean | string;
+		/**Takes a boolean or string.
+		 * If a boolean true is passed and the components model moment is not set (either through setDate or through a valid value on the input element the component is attached to) then the first time the user opens the datetimepicker widget the value is initialized to the current moment of the action.
+		 * If a false boolean is passed then no initialization happens on the input element.
+		 * You can select the granularity on the initialized moment by passing one of the following strings ("year", "month", "day", "hour", "minute") in the variable.
+		 * If for example you pass "day" to the useCurrent function and the input field is empty the first time the user opens the datetimepicker widget the input text will be initialized to the current datetime with day granularity (ie if currentTime = 2014-08-10 13:32:33 the input value will be initialized to 2014-08-10 00:00:00)
+		 * Note: If the options.defaultDate is set or the input element the component is attached to has already a value that takes precedence and the functionality of useCurrent is not triggered!
+		 */
+		useCurrent(value: boolean | string): void;
+		/**Returns the options.useStrict */
+		useStrict(): boolean;
+		/**If useStrict is true, momentjs parsing rules will be stricter when determining if a date is valid or not. */
+		useStrict(value: boolean): void;
+		/**Returns the options.viewDate option. */
+		viewDate(): boolean | moment.Moment;
+		/**This will change the viewDate without changing or setting the selected date. */
+		viewDate(value: string | Date | moment.Moment | boolean): void;
+		/**Returns the options.viewMode. */
+		viewMode(): string;
+		/**Takes a string. See valid values at DatetimepickerOptions.viewMode
+		 * Throws:
+		 * - TypeError - if the parameter is not a string or not a valid value
+		 */
+		viewMode(value: string): void;
+		/**Returns the options.widgetPositioning object */
+		widgetPositioning(): WidgetPositioningOptions;
+		/**WidgetPositioning defines where the dropdown with the widget will appear relative to the input element the component is attached to.
+		 * "auto" is the default value for both horizontal and vertical keys and it tries to automatically place the dropdown in a position that is visible to the user.
+		 * Usually you should not override those options unless you have a special need in your layout.
+		 */
+		widgetPositioning(value: WidgetPositioningOptions): void;
+	}
+
+    interface DatetimepickerOptions {
+		/**If true, the picker will show on textbox focus and icon click when used in a button group
+		 * @default: false
+		 */
+		allowInputToggle?: boolean;
+		/**Shows the week of the year to the left of first day of the week.
+		 * @default: false
+		 */
+        calendarWeeks?: boolean;
+		/**Using a Bootstraps collapse to switch between date/time pickers.
+		 * @default: true
+		 */
+        collapse?: boolean;
+		/**Disables the section of days of the week, e.g. weekends.
+		 * Accepts: array of numbers from 0-6
+		 * @default: false
+		 */
+        daysOfWeekDisabled?: Array<number> | boolean;
+		/**Changes the heading of the datepicker when in "days" view.
+		 * @default: "MMMM YYYY"
+		 */
+		dayViewHeaderFormat?: string;
+		/**Will cause the date picker to stay open after a blur event.
+		 * @default: false
+		 */
+		debug?: boolean;
+		/**Sets the picker default date/time. Overrides useCurrent
+		 * @default: false
+		 */
+        defaultDate?: boolean | moment.Moment | Date | string;
+		/**Disables selection of dates in the array, e.g. holidays
+		 * @default: false
+		 * IMPORTANT! The getter returns an Object NOT an Array, with keys being the dates, values being true.
+		 * eg disabledDates = ["2010-10-10"]; -> disabledDated will be { "2010-01-01": true }
+		 * https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1499
+		 */
+        disabledDates?: boolean | Array<moment.Moment | Date | string> | any;
+		/**Will allow or disallow hour selections (much like disabledTimeIntervals) but will affect all days
+		 * @default: false
+		 * IMPORTANT! The getter returns an Object NOT an Array, with keys being the hours, values being true.
+		 * eg disabledHours = [0, 1]; -> disabledHours will be { "0": true, "1": true }
+		 * https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1499
+		 */
+		disabledHours?: boolean | Array<number> | any;
+		/**Disables time selection between the given moments
+		 * eg: [[moment({ h: 0 }), moment({ h: 8 })], [moment({ h: 18 }), moment({ h: 24 })]]
+		 * @default: false
+		 */
+		disabledTimeIntervals?: boolean | Array<Array<moment.Moment>>;
+		/**Disables selection of dates NOT in the array, e.g. holidays
+		 * @default: false
+		 * IMPORTANT! The getter returns an Object NOT an Array, with keys being the dates, values being true.
+		 * eg enabledDates = ["2010-10-10"]; -> enabledDated will be { "2010-01-01": true }
+		 * https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1499
+		 */
+        enabledDates?: boolean | Array<moment.Moment | Date | string> | any;
+		/**Will allow or disallow hour selections (much like disabledTimeIntervals) but will affect all days
+		 * @default: false
+		 * IMPORTANT! The getter returns an Object NOT an Array, with keys being the hours, values being true.
+		 * eg enabledHours = [0, 1]; -> enabledHours will be { "0": true, "1": true }
+		 * https://github.com/Eonasdan/bootstrap-datetimepicker/issues/1499
+		 */
+		enabledHours?: boolean | Array<number>;
+		/**Allows for several input formats to be valid. See: https://github.com/Eonasdan/bootstrap-datetimepicker/pull/666
+		 * @default: false
+		 */
+		extraFormats?: boolean | Array<string>;
+		/**If false, the textbox will not be given focus when the picker is shown
+		 * @default: true
+		 */
+		focusOnShow?: boolean;
+		/**See momentjs' docs for valid formats. Format also dictates what components are shown, e.g. MM/dd/YYYY will not display the time picker.
+		 * @default: false
+		 */
+        format?: boolean | string;
+		/**Change the default icons for the pickers functions. */
+        icons?: Icons;
+		/**Allow date picker show event to fire even when the associated input element has the readonly="readonly"property.
+		 * @default: false
+		 */
+        ignoreReadonly?: boolean;
+		/**Will display the picker inline without the need of a input field. This will also hide borders and shadows.
+		 * @default: false
+		 */
+        inline?: boolean;
+		/**Allows for custom events to fire on keyboard press.
+		 * eg: keybinds: {
+		 * 		up: (widget) => console.log(widget),
+		 * 		"control up": (widget) => console.log(widget)
+		 * }
+		 * The widget parameter is false, if the datepicker is closed.
+		 */
+		keyBinds?: { [key: string]: (widget: boolean | JQuery) => void };
+		/**Will cause the date picker to not revert or overwrite invalid dates.
+		 * @default: false
+		 */
+		keepInvalid?: boolean;
+		/**Will cause the date picker to stay open after selecting a date if no time components are being used.
+		 * @default: false
+		 */
+		keepOpen?: boolean;
+		/**See momentjs for valid locales. You must include moment-with-locales.js or a local js file. 
+		 * @default: moment.locale()
+		 */
+        locale?: string;
+		/**Prevents date/time selections after this date.
+		 * maxDate will override defaultDate and useCurrent if either of these settings are the same day since both options are invalid according to the rules you've selected.
+		 * @default: false
+		 */
+        maxDate?: boolean | moment.Moment | Date | string;
+		/**Prevents date/time selections before this date.
+		 * minDate will override defaultDate and useCurrent if either of these settings are the same day since both options are invalid according to the rules you've selected.
+		 * @default: false
+		 */
+        minDate?: boolean | moment.Moment | Date | string;
+		/**Allows custom input formatting For example: the user can enter "yesterday"" or "30 days ago".
+		 * {@link http://eonasdan.github.io/bootstrap-datetimepicker/Functions/#parseinputdate}
+		 */
+		parseInputDate?: (input: string) => moment.Moment;
+		/**Show the "Clear" button in the icon toolbar.
+		 * Clicking the "Clear" button will set the calendar to null.
+		 * @default: false
+		 */
+        showClear?: boolean;
+		/**Show the "Close" button in the icon toolbar.
+		 * Clicking the "Close" button will call hide()
+		 * @default: false
+		 */
+		showClose?: boolean;
+		/**Show the "Today" button in the icon toolbar.
+		 * Clicking the "Today" button will set the calendar view and set the date to now.
+		 * @default: false
+		 */
+        showTodayButton?: boolean;
+		/**Shows the picker side by side when using the time and date together.
+		 * @default: false
+		 */
+        sideBySide?: boolean;
+		/**Number of minutes the up/down arrow's will move the minutes value in the time picker
+		 * @default: 1
+		 */
+		stepping?: number;
+		/**Changes the placement of the icon toolbar.
+		 * @default: "default"
+		 */
+        toolbarPlacement?: "default" | "top" | "bottom";
+		/**This will change the tooltips over each icon to a custom string */
+		tooltips?: Tooltips;
+		/**On show, will set the picker to the current date/time
+		 * @default: true
+		 */
+        useCurrent?: boolean;
+		/**Defines if moment should use strict date parsing when considering a date to be valid
+		 * @default: false
+		 */
+        useStrict?: boolean;
+		/**This will change the viewDate without changing or setting the selected date.
+		 * @default: false
+		 */
+		viewDate?: boolean | moment.Moment | Date | string;
+		/**The default view to display when the picker is shown.
+		 * Note: To limit the picker to selecting, for instance the year and month, use format: MM/YYYY
+		 * @default: "days"
+		 */
+        viewMode?: "decades" | "years" | "months" | "days";
+		/**On picker show, places the widget at the identifier (string) or jQuery object if the element has css position: "relative"
+		 * @default: null
+		 */
+		widgetParent?: string | JQuery;
+		widgetPositioning?: WidgetPositioningOptions;
     }
 
-    interface DatetimepickerEventObject extends JQueryEventObject {
+	interface Icons {
+		/**default: "glyphicon glyphicon-trash" */
+		clear?: string;
+		/**default: "glyphicon glyphicon-remove" */
+		close?: string;
+		/**default: "glyphicon glyphicon-calendar" */
+		date?: string;
+		/**default: "glyphicon glyphicon-time" */
+		down?: string;
+		/**default: "glyphicon glyphicon-chevron-left" */
+		next?: string;
+		/**default: "glyphicon glyphicon-screenshot" */
+		previous?: string;
+		/**default: "glyphicon glyphicon-chevron-right" */
+        time?: string;
+		/**default: "glyphicon glyphicon-chevron-down" */
+		today?: string;
+		/**default: "glyphicon glyphicon-chevron-up" */
+		up?: string;
+    }
+
+	interface Tooltips {
+		today?: string;
+		clear?: string;
+		close?: string;
+		selectMonth?: string;
+		prevMonth?: string;
+		nextMonth?: string;
+		selectYear?: string;
+		prevYear?: string;
+		nextYear?: string;
+		selectDecade?: string;
+		prevDecade?: string;
+		nextDecade?: string;
+		prevCentury?: string;
+		nextCentury?: string;
+		selectTime?: string;
+		pickHour?: string;
+		incrementHour?: string;
+		decrementHour?: string;
+		pickMinute?: string;
+		incrementMinute?: string;
+		decrementMinute?: string;
+		togglePeriod?: string;
+		pickSecond?: string;
+		incrementSecond?: string;
+		decrementSecond?: string;
+	}
+
+	interface WidgetPositioningOptions {
+		horizontal?: "auto" | "left" | "right";
+		vertical?: "auto" | "top" | "bottom";
+	}
+
+    interface Event extends JQueryEventObject {
         date: moment.Moment;
     }
 
-    interface DatetimepickerIcons {
-        time?: string;
-        date?: string;
-        up?: string;
-        down?: string;
-    }
-
-    interface DatetimepickerOptions {
-        pickDate?: boolean;
-        pickTime?: boolean;
-        useMinutes?: boolean;
-        useSeconds?: boolean;
-        useCurrent?: boolean;
-        minuteStepping?: number;
-        minDate?: moment.Moment | Date | string;
-        maxDate?: moment.Moment | Date | string;
-        showToday?: boolean;
-        collapse?: boolean;
-        language?: string;
-        defaultDate?: moment.Moment | Date | string;
-        disabledDates?: Array<moment.Moment | Date | string>;
-        enabledDates?: Array<moment.Moment | Date | string>;
-        icons?: DatetimepickerIcons;
-        useStrict?: boolean;
-        direction?: string;
-        sideBySide?: boolean;
-        daysOfWeekDisabled?: Array<number>;
-        calendarWeeks?: boolean;
-        format?: string | boolean;
-        locale?: string;
-        showTodayButton?: boolean;
-        viewMode?: string;
-        inline?: boolean;
-        toolbarPlacement?: string;
-        showClear?: boolean;
-        ignoreReadonly?: boolean;
-    }
-
-    interface Datetimepicker {
-        date(date: moment.Moment | Date | string): void;
-        date(): moment.Moment;
-        minDate(date: moment.Moment | Date | string): void;
-        minDate(): moment.Moment | boolean;
-        maxDate(date: moment.Moment | Date | string): void;
-        maxDate(): moment.Moment | boolean;
-        show(): void;
-        disable(): void;
-        enable(): void;
-        destroy(): void;
-        toggle(): void;
+    interface ChangeEvent extends Event {
+		/**Previous date. False if the previous date is null. */
+        oldDate: moment.Moment | boolean;
     }
 
+	interface UpdateEvent extends JQueryEventObject {
+		/**Change type as a momentjs format token. e.g. yyyy on year change */
+		change: string;
+		/**New viewDate. */
+		viewDate: moment.Moment;
+	}
 }
 
-
 interface JQuery {
 
     datetimepicker(): JQuery;
     datetimepicker(options: BootstrapV3DatetimePicker.DatetimepickerOptions): JQuery;
 
-    off(events: "dp.change", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
-    off(events: "dp.change", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+    data(key: "DateTimePicker"): BootstrapV3DatetimePicker.Datetimepicker;
 
-    on(events: "dp.change", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
-    on(events: "dp.change", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
-    on(events: 'dp.change', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerChangeEventObject) => any): JQuery;
+    on(events: "dp.change", handler: (eventObject: BootstrapV3DatetimePicker.ChangeEvent) => any): JQuery;
+    on(events: "dp.change", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.ChangeEvent) => any): JQuery;
+    on(events: "dp.change", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.ChangeEvent) => any): JQuery;
 
-    off(events: "dp.show", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    off(events: "dp.show", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    off(events: "dp.change", handler: (eventobject: BootstrapV3DatetimePicker.ChangeEvent) => any): JQuery;
+    off(events: "dp.change", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.ChangeEvent) => any): JQuery;
 
-    on(events: "dp.show", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: "dp.show", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: 'dp.show', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
 
-    off(events: "dp.hide", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    off(events: "dp.hide", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: "dp.show", handler: (eventObject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.show", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.show", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
 
-    on(events: "dp.hide", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: "dp.hide", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: 'dp.hide', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    off(events: "dp.show", handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    off(events: "dp.show", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
 
-    off(events: "dp.error", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    off(events: "dp.error", handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
 
-    on(events: "dp.error", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: "dp.error", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
-    on(events: 'dp.error', handler: (eventObject: BootstrapV3DatetimePicker.DatetimepickerEventObject) => any): JQuery;
+    on(events: "dp.hide", handler: (eventObject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.hide", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.hide", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
 
-    data(key: 'DateTimePicker'): BootstrapV3DatetimePicker.Datetimepicker;
-}
+    off(events: "dp.hide", handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    off(events: "dp.hide", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+
+
+    on(events: "dp.error", handler: (eventObject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.error", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    on(events: "dp.error", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+
+    off(events: "dp.error", handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    off(events: "dp.error", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+
+
+    on(events: "dp.update", handler: (eventObject: BootstrapV3DatetimePicker.UpdateEvent) => any): JQuery;
+    on(events: "dp.update", selector: string, handler: (eventobject: BootstrapV3DatetimePicker.UpdateEvent) => any): JQuery;
+    on(events: "dp.update", selector: string, data: any, handler?: (eventobject: BootstrapV3DatetimePicker.UpdateEvent) => any): JQuery;
+
+    off(events: "dp.update", handler: (eventobject: BootstrapV3DatetimePicker.Event) => any): JQuery;
+    off(events: "dp.update", selector?: string, handler?: (eventobject: BootstrapV3DatetimePicker.UpdateEvent) => any): JQuery;
+}
\ No newline at end of file
diff --git a/chokidar/chokidar.d.ts b/chokidar/chokidar.d.ts
index 6a417ca72..be5dd4081 100644
--- a/chokidar/chokidar.d.ts
+++ b/chokidar/chokidar.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for chokidar 1.0.0
+// Type definitions for chokidar 1.4.3
 // Project: https://github.com/paulmillr/chokidar
 // Definitions by: Stefan Steinhart <https://github.com/reppners/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -13,6 +13,7 @@ declare module "fs"
         add(filesDirsOrGlobs:Array<string>):void;
         unwatch(fileDirOrGlob:string):void;
         unwatch(filesDirsOrGlobs:Array<string>):void;
+        getWatched():any;
     }
 }
 
@@ -33,10 +34,11 @@ declare module "chokidar"
         binaryInterval?:number;
         ignorePermissionErrors?:boolean;
         atomic?:boolean;
+        awaitWriteFinish?:any;
     }
 
     import fs = require("fs");
 
-    function watch( fileDirOrGlob:string, options?:WatchOptions ):fs.FSWatcher;
-    function watch( filesDirsOrGlobs:Array<string>, options?:WatchOptions ):fs.FSWatcher;
+    function watch(fileDirOrGlob:string, options?:WatchOptions):fs.FSWatcher;
+    function watch(filesDirsOrGlobs:Array<string>, options?:WatchOptions):fs.FSWatcher;
 }
diff --git a/chrome/chrome.d.ts b/chrome/chrome.d.ts
index fccb84895..357229920 100644
--- a/chrome/chrome.d.ts
+++ b/chrome/chrome.d.ts
@@ -5312,7 +5312,7 @@ declare module chrome.runtime {
 	 * Fired when a connection is made from another extension.
 	 * @since Chrome 26.
 	 */
-	var onConnectExternal: RuntimeEvent;
+	var onConnectExternal: ExtensionConnectEvent;
 	/** Sent to the event page just before it is unloaded. This gives the extension opportunity to do some clean up. Note that since the page is unloading, any asynchronous operations started while handling this event are not guaranteed to complete. If more activity for the event page occurs before it gets unloaded the onSuspendCanceled event will be sent and the page won't be unloaded. */
 	var onSuspend: RuntimeEvent;
 	/**
diff --git a/codemirror/codemirror-runmode-tests.ts b/codemirror/codemirror-runmode-tests.ts
new file mode 100644
index 000000000..e139e7177
--- /dev/null
+++ b/codemirror/codemirror-runmode-tests.ts
@@ -0,0 +1,6 @@
+/// <reference path="codemirror.d.ts" />
+/// <reference path="codemirror-runmode.d.ts" />
+
+var query = "SELECT * FROM Table";
+
+CodeMirror.runMode(query, "text/x-sql", document.body);
diff --git a/codemirror/codemirror-runmode.d.ts b/codemirror/codemirror-runmode.d.ts
new file mode 100644
index 000000000..58a8330a8
--- /dev/null
+++ b/codemirror/codemirror-runmode.d.ts
@@ -0,0 +1,22 @@
+// Type definitions for CodeMirror
+// Project: https://github.com/marijnh/CodeMirror
+// Definitions by: Joseph Vaughan <https://github.com/Joev->
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+// See docs https://codemirror.net/doc/manual.html#addon_runmode
+
+declare module CodeMirror {
+
+    /**
+     * Runs a CodeMirror mode over text without opening an editor instance.
+     *
+     * @param text The document to run through the highlighter.
+     * @param mode The mode to use (must be loaded as normal).
+     * @param output If this is a function, it will be called for each token with
+     *               two arguments, the token's text and the token's style class
+     *               (may be null for unstyled tokens). If it is a DOM node, the
+     *               tokens will be converted to span elements as in an editor,
+     *               and inserted into the node (through innerHTML).
+     */
+    function runMode(text: string, modespec: any, callback: (HTMLElement | ((text: string, style: string) => void)), options? : { tabSize?: number; state?: any; }): void;
+}
diff --git a/d3/d3.d.ts b/d3/d3.d.ts
index bb7fd3d1b..eff11b3e0 100644
--- a/d3/d3.d.ts
+++ b/d3/d3.d.ts
@@ -2488,7 +2488,7 @@ declare module d3 {
         }
 
         interface Diagonal<Link, Node> {
-            (d: Link, i: number): string;
+            (d: Link, i?: number): string;
 
             source(): (d: Link, i: number) => Node;
             source(source: Node): Diagonal<Link, Node>;
diff --git a/eventemitter3/eventemitter3-tests.ts b/eventemitter3/eventemitter3-tests.ts
index 49ae0a24d..6c5733bec 100644
--- a/eventemitter3/eventemitter3-tests.ts
+++ b/eventemitter3/eventemitter3-tests.ts
@@ -105,6 +105,10 @@ describe('EventEmitter', function tests() {
       /* rawr, i'm a beast */
     }
 
+    class BeastES6 extends EventEmitter3ImportedAsES6Module {
+      /* rawr, i'm a beast */
+    }
+
     util.inherits(Beast, EventEmitter);
 
     var moop = new Beast()
diff --git a/express-serve-static-core/express-serve-static-core-tests.ts b/express-serve-static-core/express-serve-static-core-tests.ts
new file mode 100644
index 000000000..a89769c93
--- /dev/null
+++ b/express-serve-static-core/express-serve-static-core-tests.ts
@@ -0,0 +1,5 @@
+/// <reference path="express-serve-static-core.d.ts" />
+
+import * as express from 'express-serve-static-core';
+
+// null test file - everything should be tested from express.d.ts and serve-static.d.ts
\ No newline at end of file
diff --git a/express-serve-static-core/express-serve-static-core.d.ts b/express-serve-static-core/express-serve-static-core.d.ts
new file mode 100644
index 000000000..b0fb1f36d
--- /dev/null
+++ b/express-serve-static-core/express-serve-static-core.d.ts
@@ -0,0 +1,1063 @@
+// Type definitions for Express 4.x
+// Project: http://expressjs.com
+// Definitions by: Boris Yankov <https://github.com/borisyankov/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// This extracts the core definitions from express to prevent a circular dependency between express and serve-static
+/// <reference path="../node/node.d.ts" />
+
+declare module Express {
+
+    // These open interfaces may be extended in an application-specific manner via declaration merging.
+    // See for example method-override.d.ts (https://github.com/borisyankov/DefinitelyTyped/blob/master/method-override/method-override.d.ts)
+    export interface Request { }
+    export interface Response { }
+    export interface Application { }
+}
+
+declare module "express-serve-static-core" {
+    import * as http from "http";
+
+    interface IRoute {
+        path: string;
+        stack: any;
+        all(...handler: RequestHandler[]): IRoute;
+        get(...handler: RequestHandler[]): IRoute;
+        post(...handler: RequestHandler[]): IRoute;
+        put(...handler: RequestHandler[]): IRoute;
+        delete(...handler: RequestHandler[]): IRoute;
+        patch(...handler: RequestHandler[]): IRoute;
+        options(...handler: RequestHandler[]): IRoute;
+        head(...handler: RequestHandler[]): IRoute;
+    }
+
+    interface IRouterMatcher<T> {
+        (name: string | RegExp, ...handlers: RequestHandler[]): T;
+    }
+
+    interface IRouter<T> extends RequestHandler {
+        /**
+            * Map the given param placeholder `name`(s) to the given callback(s).
+            *
+            * Parameter mapping is used to provide pre-conditions to routes
+            * which use normalized placeholders. For example a _:user_id_ parameter
+            * could automatically load a user's information from the database without
+            * any additional code,
+            *
+            * The callback uses the samesignature as middleware, the only differencing
+            * being that the value of the placeholder is passed, in this case the _id_
+            * of the user. Once the `next()` function is invoked, just like middleware
+            * it will continue on to execute the route, or subsequent parameter functions.
+            *
+            *      app.param('user_id', function(req, res, next, id){
+            *        User.find(id, function(err, user){
+            *          if (err) {
+            *            next(err);
+            *          } else if (user) {
+            *            req.user = user;
+            *            next();
+            *          } else {
+            *            next(new Error('failed to load user'));
+            *          }
+            *        });
+            *      });
+            *
+            * @param name
+            * @param fn
+            */
+        param(name: string, handler: RequestParamHandler): T;
+        param(name: string, matcher: RegExp): T;
+        param(name: string, mapper: (param: any) => any): T;
+        // Alternatively, you can pass only a callback, in which case you have the opportunity to alter the app.param() API
+        param(callback: (name: string, matcher: RegExp) => RequestParamHandler): T;
+
+        /**
+            * Special-cased "all" method, applying the given route `path`,
+            * middleware, and callback to _every_ HTTP method.
+            *
+            * @param path
+            * @param fn
+            */
+        all: IRouterMatcher<T>;
+        get: IRouterMatcher<T>;
+        post: IRouterMatcher<T>;
+        put: IRouterMatcher<T>;
+        delete: IRouterMatcher<T>;
+        patch: IRouterMatcher<T>;
+        options: IRouterMatcher<T>;
+        head: IRouterMatcher<T>;
+
+        route(path: string): IRoute;
+
+        use(...handler: RequestHandler[]): T;
+        use(handler: ErrorRequestHandler | RequestHandler): T;
+        use(path: string, ...handler: RequestHandler[]): T;
+        use(path: string, handler: ErrorRequestHandler | RequestHandler): T;
+        use(path: string[], ...handler: RequestHandler[]): T;
+        use(path: string[], handler: ErrorRequestHandler): T;
+        use(path: RegExp, ...handler: RequestHandler[]): T;
+        use(path: RegExp, handler: ErrorRequestHandler): T;
+        use(path: string, router: Router): T;
+    }
+
+
+    export interface Router extends IRouter<Router> { }
+
+    interface CookieOptions {
+        maxAge?: number;
+        signed?: boolean;
+        expires?: Date;
+        httpOnly?: boolean;
+        path?: string;
+        domain?: string;
+        secure?: boolean;
+    }
+
+    interface Errback { (err: Error): void; }
+
+    interface Request extends http.ServerRequest, Express.Request {
+
+        /**
+            * Return request header.
+            *
+            * The `Referrer` header field is special-cased,
+            * both `Referrer` and `Referer` are interchangeable.
+            *
+            * Examples:
+            *
+            *     req.get('Content-Type');
+            *     // => "text/plain"
+            *
+            *     req.get('content-type');
+            *     // => "text/plain"
+            *
+            *     req.get('Something');
+            *     // => undefined
+            *
+            * Aliased as `req.header()`.
+            *
+            * @param name
+            */
+        get(name: string): string;
+
+        header(name: string): string;
+
+        headers: { [key: string]: string; };
+
+        /**
+            * Check if the given `type(s)` is acceptable, returning
+            * the best match when true, otherwise `undefined`, in which
+            * case you should respond with 406 "Not Acceptable".
+            *
+            * The `type` value may be a single mime type string
+            * such as "application/json", the extension name
+            * such as "json", a comma-delimted list such as "json, html, text/plain",
+            * or an array `["json", "html", "text/plain"]`. When a list
+            * or array is given the _best_ match, if any is returned.
+            *
+            * Examples:
+            *
+            *     // Accept: text/html
+            *     req.accepts('html');
+            *     // => "html"
+            *
+            *     // Accept: text/*, application/json
+            *     req.accepts('html');
+            *     // => "html"
+            *     req.accepts('text/html');
+            *     // => "text/html"
+            *     req.accepts('json, text');
+            *     // => "json"
+            *     req.accepts('application/json');
+            *     // => "application/json"
+            *
+            *     // Accept: text/*, application/json
+            *     req.accepts('image/png');
+            *     req.accepts('png');
+            *     // => undefined
+            *
+            *     // Accept: text/*;q=.5, application/json
+            *     req.accepts(['html', 'json']);
+            *     req.accepts('html, json');
+            *     // => "json"
+            */
+        accepts(type: string): string;
+
+        accepts(type: string[]): string;
+
+        /**
+            * Returns the first accepted charset of the specified character sets,
+            * based on the request’s Accept-Charset HTTP header field.
+            * If none of the specified charsets is accepted, returns false.
+            *
+            * For more information, or if you have issues or concerns, see accepts.
+            * @param charset
+            */
+        acceptsCharsets(charset?: string | string[]): string[];
+
+        /**
+            * Returns the first accepted encoding of the specified encodings,
+            * based on the request’s Accept-Encoding HTTP header field.
+            * If none of the specified encodings is accepted, returns false.
+            *
+            * For more information, or if you have issues or concerns, see accepts.
+            * @param encoding
+            */
+        acceptsEncodings(encoding?: string | string[]): string[];
+
+        /**
+            * Returns the first accepted language of the specified languages,
+            * based on the request’s Accept-Language HTTP header field.
+            * If none of the specified languages is accepted, returns false.
+            *
+            * For more information, or if you have issues or concerns, see accepts.
+            *
+            * @param lang
+            */
+        acceptsLanguages(lang?: string | string[]): string[];
+
+        /**
+            * Parse Range header field,
+            * capping to the given `size`.
+            *
+            * Unspecified ranges such as "0-" require
+            * knowledge of your resource length. In
+            * the case of a byte range this is of course
+            * the total number of bytes. If the Range
+            * header field is not given `null` is returned,
+            * `-1` when unsatisfiable, `-2` when syntactically invalid.
+            *
+            * NOTE: remember that ranges are inclusive, so
+            * for example "Range: users=0-3" should respond
+            * with 4 users when available, not 3.
+            *
+            * @param size
+            */
+        range(size: number): any[];
+
+        /**
+            * Return an array of Accepted media types
+            * ordered from highest quality to lowest.
+            */
+        accepted: MediaType[];
+
+        /**
+            * Return the value of param `name` when present or `defaultValue`.
+            *
+            *  - Checks route placeholders, ex: _/user/:id_
+            *  - Checks body params, ex: id=12, {"id":12}
+            *  - Checks query string params, ex: ?id=12
+            *
+            * To utilize request bodies, `req.body`
+            * should be an object. This can be done by using
+            * the `connect.bodyParser()` middleware.
+            *
+            * @param name
+            * @param defaultValue
+            */
+        param(name: string, defaultValue?: any): string;
+
+        /**
+            * Check if the incoming request contains the "Content-Type"
+            * header field, and it contains the give mime `type`.
+            *
+            * Examples:
+            *
+            *      // With Content-Type: text/html; charset=utf-8
+            *      req.is('html');
+            *      req.is('text/html');
+            *      req.is('text/*');
+            *      // => true
+            *
+            *      // When Content-Type is application/json
+            *      req.is('json');
+            *      req.is('application/json');
+            *      req.is('application/*');
+            *      // => true
+            *
+            *      req.is('html');
+            *      // => false
+            *
+            * @param type
+            */
+        is(type: string): boolean;
+
+        /**
+            * Return the protocol string "http" or "https"
+            * when requested with TLS. When the "trust proxy"
+            * setting is enabled the "X-Forwarded-Proto" header
+            * field will be trusted. If you're running behind
+            * a reverse proxy that supplies https for you this
+            * may be enabled.
+            */
+        protocol: string;
+
+        /**
+            * Short-hand for:
+            *
+            *    req.protocol == 'https'
+            */
+        secure: boolean;
+
+        /**
+            * Return the remote address, or when
+            * "trust proxy" is `true` return
+            * the upstream addr.
+            */
+        ip: string;
+
+        /**
+            * When "trust proxy" is `true`, parse
+            * the "X-Forwarded-For" ip address list.
+            *
+            * For example if the value were "client, proxy1, proxy2"
+            * you would receive the array `["client", "proxy1", "proxy2"]`
+            * where "proxy2" is the furthest down-stream.
+            */
+        ips: string[];
+
+        /**
+            * Return subdomains as an array.
+            *
+            * Subdomains are the dot-separated parts of the host before the main domain of
+            * the app. By default, the domain of the app is assumed to be the last two
+            * parts of the host. This can be changed by setting "subdomain offset".
+            *
+            * For example, if the domain is "tobi.ferrets.example.com":
+            * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
+            * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
+            */
+        subdomains: string[];
+
+        /**
+            * Short-hand for `url.parse(req.url).pathname`.
+            */
+        path: string;
+
+        /**
+            * Parse the "Host" header field hostname.
+            */
+        hostname: string;
+
+        /**
+            * @deprecated Use hostname instead.
+            */
+        host: string;
+
+        /**
+            * Check if the request is fresh, aka
+            * Last-Modified and/or the ETag
+            * still match.
+            */
+        fresh: boolean;
+
+        /**
+            * Check if the request is stale, aka
+            * "Last-Modified" and / or the "ETag" for the
+            * resource has changed.
+            */
+        stale: boolean;
+
+        /**
+            * Check if the request was an _XMLHttpRequest_.
+            */
+        xhr: boolean;
+
+        //body: { username: string; password: string; remember: boolean; title: string; };
+        body: any;
+
+        //cookies: { string; remember: boolean; };
+        cookies: any;
+
+        method: string;
+
+        params: any;
+
+        user: any;
+
+        authenticatedUser: any;
+
+        /**
+            * Clear cookie `name`.
+            *
+            * @param name
+            * @param options
+            */
+        clearCookie(name: string, options?: any): Response;
+
+        query: any;
+
+        route: any;
+
+        signedCookies: any;
+
+        originalUrl: string;
+
+        url: string;
+
+        baseUrl: string;
+
+        app: Application;
+    }
+
+    interface MediaType {
+        value: string;
+        quality: number;
+        type: string;
+        subtype: string;
+    }
+
+    interface Send {
+        (status: number, body?: any): Response;
+        (body: any): Response;
+    }
+
+    interface Response extends http.ServerResponse, Express.Response {
+        /**
+            * Set status `code`.
+            *
+            * @param code
+            */
+        status(code: number): Response;
+
+        /**
+            * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
+            * @link http://expressjs.com/4x/api.html#res.sendStatus
+            *
+            * Examples:
+            *
+            *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
+            *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
+            *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
+            *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
+            *
+            * @param code
+            */
+        sendStatus(code: number): Response;
+
+        /**
+            * Set Link header field with the given `links`.
+            *
+            * Examples:
+            *
+            *    res.links({
+            *      next: 'http://api.example.com/users?page=2',
+            *      last: 'http://api.example.com/users?page=5'
+            *    });
+            *
+            * @param links
+            */
+        links(links: any): Response;
+
+        /**
+            * Send a response.
+            *
+            * Examples:
+            *
+            *     res.send(new Buffer('wahoo'));
+            *     res.send({ some: 'json' });
+            *     res.send('<p>some html</p>');
+            *     res.send(404, 'Sorry, cant find that');
+            *     res.send(404);
+            */
+        send: Send;
+
+        /**
+            * Send JSON response.
+            *
+            * Examples:
+            *
+            *     res.json(null);
+            *     res.json({ user: 'tj' });
+            *     res.json(500, 'oh noes!');
+            *     res.json(404, 'I dont have that');
+            */
+        json: Send;
+
+        /**
+            * Send JSON response with JSONP callback support.
+            *
+            * Examples:
+            *
+            *     res.jsonp(null);
+            *     res.jsonp({ user: 'tj' });
+            *     res.jsonp(500, 'oh noes!');
+            *     res.jsonp(404, 'I dont have that');
+            */
+        jsonp: Send;
+
+        /**
+            * Transfer the file at the given `path`.
+            *
+            * Automatically sets the _Content-Type_ response header field.
+            * The callback `fn(err)` is invoked when the transfer is complete
+            * or when an error occurs. Be sure to check `res.sentHeader`
+            * if you wish to attempt responding, as the header and some data
+            * may have already been transferred.
+            *
+            * Options:
+            *
+            *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
+            *   - `root`     root directory for relative filenames
+            *   - `headers`  object of headers to serve with file
+            *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
+            *
+            * Other options are passed along to `send`.
+            *
+            * Examples:
+            *
+            *  The following example illustrates how `res.sendFile()` may
+            *  be used as an alternative for the `static()` middleware for
+            *  dynamic situations. The code backing `res.sendFile()` is actually
+            *  the same code, so HTTP cache support etc is identical.
+            *
+            *     app.get('/user/:uid/photos/:file', function(req, res){
+            *       var uid = req.params.uid
+            *         , file = req.params.file;
+            *
+            *       req.user.mayViewFilesFrom(uid, function(yes){
+            *         if (yes) {
+            *           res.sendFile('/uploads/' + uid + '/' + file);
+            *         } else {
+            *           res.send(403, 'Sorry! you cant see that.');
+            *         }
+            *       });
+            *     });
+            *
+            * @api public
+            */
+        sendFile(path: string): void;
+        sendFile(path: string, options: any): void;
+        sendFile(path: string, fn: Errback): void;
+        sendFile(path: string, options: any, fn: Errback): void;
+
+        /**
+            * @deprecated Use sendFile instead.
+            */
+        sendfile(path: string): void;
+        /**
+            * @deprecated Use sendFile instead.
+            */
+        sendfile(path: string, options: any): void;
+        /**
+            * @deprecated Use sendFile instead.
+            */
+        sendfile(path: string, fn: Errback): void;
+        /**
+            * @deprecated Use sendFile instead.
+            */
+        sendfile(path: string, options: any, fn: Errback): void;
+
+        /**
+            * Transfer the file at the given `path` as an attachment.
+            *
+            * Optionally providing an alternate attachment `filename`,
+            * and optional callback `fn(err)`. The callback is invoked
+            * when the data transfer is complete, or when an error has
+            * ocurred. Be sure to check `res.headerSent` if you plan to respond.
+            *
+            * This method uses `res.sendfile()`.
+            */
+        download(path: string): void;
+        download(path: string, filename: string): void;
+        download(path: string, fn: Errback): void;
+        download(path: string, filename: string, fn: Errback): void;
+
+        /**
+            * Set _Content-Type_ response header with `type` through `mime.lookup()`
+            * when it does not contain "/", or set the Content-Type to `type` otherwise.
+            *
+            * Examples:
+            *
+            *     res.type('.html');
+            *     res.type('html');
+            *     res.type('json');
+            *     res.type('application/json');
+            *     res.type('png');
+            *
+            * @param type
+            */
+        contentType(type: string): Response;
+
+        /**
+            * Set _Content-Type_ response header with `type` through `mime.lookup()`
+            * when it does not contain "/", or set the Content-Type to `type` otherwise.
+            *
+            * Examples:
+            *
+            *     res.type('.html');
+            *     res.type('html');
+            *     res.type('json');
+            *     res.type('application/json');
+            *     res.type('png');
+            *
+            * @param type
+            */
+        type(type: string): Response;
+
+        /**
+            * Respond to the Acceptable formats using an `obj`
+            * of mime-type callbacks.
+            *
+            * This method uses `req.accepted`, an array of
+            * acceptable types ordered by their quality values.
+            * When "Accept" is not present the _first_ callback
+            * is invoked, otherwise the first match is used. When
+            * no match is performed the server responds with
+            * 406 "Not Acceptable".
+            *
+            * Content-Type is set for you, however if you choose
+            * you may alter this within the callback using `res.type()`
+            * or `res.set('Content-Type', ...)`.
+            *
+            *    res.format({
+            *      'text/plain': function(){
+            *        res.send('hey');
+            *      },
+            *
+            *      'text/html': function(){
+            *        res.send('<p>hey</p>');
+            *      },
+            *
+            *      'appliation/json': function(){
+            *        res.send({ message: 'hey' });
+            *      }
+            *    });
+            *
+            * In addition to canonicalized MIME types you may
+            * also use extnames mapped to these types:
+            *
+            *    res.format({
+            *      text: function(){
+            *        res.send('hey');
+            *      },
+            *
+            *      html: function(){
+            *        res.send('<p>hey</p>');
+            *      },
+            *
+            *      json: function(){
+            *        res.send({ message: 'hey' });
+            *      }
+            *    });
+            *
+            * By default Express passes an `Error`
+            * with a `.status` of 406 to `next(err)`
+            * if a match is not made. If you provide
+            * a `.default` callback it will be invoked
+            * instead.
+            *
+            * @param obj
+            */
+        format(obj: any): Response;
+
+        /**
+            * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
+            *
+            * @param filename
+            */
+        attachment(filename?: string): Response;
+
+        /**
+            * Set header `field` to `val`, or pass
+            * an object of header fields.
+            *
+            * Examples:
+            *
+            *    res.set('Foo', ['bar', 'baz']);
+            *    res.set('Accept', 'application/json');
+            *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
+            *
+            * Aliased as `res.header()`.
+            */
+        set(field: any): Response;
+        set(field: string, value?: string): Response;
+
+        header(field: any): Response;
+        header(field: string, value?: string): Response;
+
+        // Property indicating if HTTP headers has been sent for the response.
+        headersSent: boolean;
+
+        /**
+            * Get value for header `field`.
+            *
+            * @param field
+            */
+        get(field: string): string;
+
+        /**
+            * Clear cookie `name`.
+            *
+            * @param name
+            * @param options
+            */
+        clearCookie(name: string, options?: any): Response;
+
+        /**
+            * Set cookie `name` to `val`, with the given `options`.
+            *
+            * Options:
+            *
+            *    - `maxAge`   max-age in milliseconds, converted to `expires`
+            *    - `signed`   sign the cookie
+            *    - `path`     defaults to "/"
+            *
+            * Examples:
+            *
+            *    // "Remember Me" for 15 minutes
+            *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
+            *
+            *    // save as above
+            *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
+            */
+        cookie(name: string, val: string, options: CookieOptions): Response;
+        cookie(name: string, val: any, options: CookieOptions): Response;
+        cookie(name: string, val: any): Response;
+
+        /**
+            * Set the location header to `url`.
+            *
+            * The given `url` can also be the name of a mapped url, for
+            * example by default express supports "back" which redirects
+            * to the _Referrer_ or _Referer_ headers or "/".
+            *
+            * Examples:
+            *
+            *    res.location('/foo/bar').;
+            *    res.location('http://example.com');
+            *    res.location('../login'); // /blog/post/1 -> /blog/login
+            *
+            * Mounting:
+            *
+            *   When an application is mounted and `res.location()`
+            *   is given a path that does _not_ lead with "/" it becomes
+            *   relative to the mount-point. For example if the application
+            *   is mounted at "/blog", the following would become "/blog/login".
+            *
+            *      res.location('login');
+            *
+            *   While the leading slash would result in a location of "/login":
+            *
+            *      res.location('/login');
+            *
+            * @param url
+            */
+        location(url: string): Response;
+
+        /**
+            * Redirect to the given `url` with optional response `status`
+            * defaulting to 302.
+            *
+            * The resulting `url` is determined by `res.location()`, so
+            * it will play nicely with mounted apps, relative paths,
+            * `"back"` etc.
+            *
+            * Examples:
+            *
+            *    res.redirect('/foo/bar');
+            *    res.redirect('http://example.com');
+            *    res.redirect(301, 'http://example.com');
+            *    res.redirect('http://example.com', 301);
+            *    res.redirect('../login'); // /blog/post/1 -> /blog/login
+            */
+        redirect(url: string): void;
+        redirect(status: number, url: string): void;
+        redirect(url: string, status: number): void;
+
+        /**
+            * Render `view` with the given `options` and optional callback `fn`.
+            * When a callback function is given a response will _not_ be made
+            * automatically, otherwise a response of _200_ and _text/html_ is given.
+            *
+            * Options:
+            *
+            *  - `cache`     boolean hinting to the engine it should cache
+            *  - `filename`  filename of the view being rendered
+            */
+        render(view: string, options?: Object, callback?: (err: Error, html: string) => void): void;
+        render(view: string, callback?: (err: Error, html: string) => void): void;
+
+        locals: any;
+
+        charset: string;
+    }
+
+    interface NextFunction {
+        (): void;
+        (err: any): void;
+    }
+
+    interface ErrorRequestHandler {
+        (err: any, req: Request, res: Response, next: NextFunction): any;
+    }
+
+
+    interface Handler extends RequestHandler { }
+
+    interface RequestParamHandler {
+        (req: Request, res: Response, next: NextFunction, param: any): any;
+    }
+
+    interface Application extends IRouter<Application>, Express.Application {
+        /**
+            * Initialize the server.
+            *
+            *   - setup default configuration
+            *   - setup default middleware
+            *   - setup route reflection methods
+            */
+        init(): void;
+
+        /**
+            * Initialize application configuration.
+            */
+        defaultConfiguration(): void;
+
+        /**
+            * Register the given template engine callback `fn`
+            * as `ext`.
+            *
+            * By default will `require()` the engine based on the
+            * file extension. For example if you try to render
+            * a "foo.jade" file Express will invoke the following internally:
+            *
+            *     app.engine('jade', require('jade').__express);
+            *
+            * For engines that do not provide `.__express` out of the box,
+            * or if you wish to "map" a different extension to the template engine
+            * you may use this method. For example mapping the EJS template engine to
+            * ".html" files:
+            *
+            *     app.engine('html', require('ejs').renderFile);
+            *
+            * In this case EJS provides a `.renderFile()` method with
+            * the same signature that Express expects: `(path, options, callback)`,
+            * though note that it aliases this method as `ejs.__express` internally
+            * so if you're using ".ejs" extensions you dont need to do anything.
+            *
+            * Some template engines do not follow this convention, the
+            * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
+            * library was created to map all of node's popular template
+            * engines to follow this convention, thus allowing them to
+            * work seamlessly within Express.
+            */
+        engine(ext: string, fn: Function): Application;
+
+        /**
+            * Assign `setting` to `val`, or return `setting`'s value.
+            *
+            *    app.set('foo', 'bar');
+            *    app.get('foo');
+            *    // => "bar"
+            *    app.set('foo', ['bar', 'baz']);
+            *    app.get('foo');
+            *    // => ["bar", "baz"]
+            *
+            * Mounted servers inherit their parent server's settings.
+            *
+            * @param setting
+            * @param val
+            */
+        set(setting: string, val: any): Application;
+        get: {
+            (name: string): any; // Getter
+            (name: string | RegExp, ...handlers: RequestHandler[]): Application;
+        };
+
+        /**
+            * Return the app's absolute pathname
+            * based on the parent(s) that have
+            * mounted it.
+            *
+            * For example if the application was
+            * mounted as "/admin", which itself
+            * was mounted as "/blog" then the
+            * return value would be "/blog/admin".
+            */
+        path(): string;
+
+        /**
+            * Check if `setting` is enabled (truthy).
+            *
+            *    app.enabled('foo')
+            *    // => false
+            *
+            *    app.enable('foo')
+            *    app.enabled('foo')
+            *    // => true
+            */
+        enabled(setting: string): boolean;
+
+        /**
+            * Check if `setting` is disabled.
+            *
+            *    app.disabled('foo')
+            *    // => true
+            *
+            *    app.enable('foo')
+            *    app.disabled('foo')
+            *    // => false
+            *
+            * @param setting
+            */
+        disabled(setting: string): boolean;
+
+        /**
+            * Enable `setting`.
+            *
+            * @param setting
+            */
+        enable(setting: string): Application;
+
+        /**
+            * Disable `setting`.
+            *
+            * @param setting
+            */
+        disable(setting: string): Application;
+
+        /**
+            * Configure callback for zero or more envs,
+            * when no `env` is specified that callback will
+            * be invoked for all environments. Any combination
+            * can be used multiple times, in any order desired.
+            *
+            * Examples:
+            *
+            *    app.configure(function(){
+            *      // executed for all envs
+            *    });
+            *
+            *    app.configure('stage', function(){
+            *      // executed staging env
+            *    });
+            *
+            *    app.configure('stage', 'production', function(){
+            *      // executed for stage and production
+            *    });
+            *
+            * Note:
+            *
+            *  These callbacks are invoked immediately, and
+            *  are effectively sugar for the following:
+            *
+            *     var env = process.env.NODE_ENV || 'development';
+            *
+            *      switch (env) {
+            *        case 'development':
+            *          ...
+            *          break;
+            *        case 'stage':
+            *          ...
+            *          break;
+            *        case 'production':
+            *          ...
+            *          break;
+            *      }
+            *
+            * @param env
+            * @param fn
+            */
+        configure(fn: Function): Application;
+        configure(env0: string, fn: Function): Application;
+        configure(env0: string, env1: string, fn: Function): Application;
+        configure(env0: string, env1: string, env2: string, fn: Function): Application;
+        configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
+        configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
+
+        /**
+            * Render the given view `name` name with `options`
+            * and a callback accepting an error and the
+            * rendered template string.
+            *
+            * Example:
+            *
+            *    app.render('email', { name: 'Tobi' }, function(err, html){
+            *      // ...
+            *    })
+            *
+            * @param name
+            * @param options or fn
+            * @param fn
+            */
+        render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
+        render(name: string, callback: (err: Error, html: string) => void): void;
+
+
+        /**
+            * Listen for connections.
+            *
+            * A node `http.Server` is returned, with this
+            * application (which is a `Function`) as its
+            * callback. If you wish to create both an HTTP
+            * and HTTPS server you may do so with the "http"
+            * and "https" modules as shown here:
+            *
+            *    var http = require('http')
+            *      , https = require('https')
+            *      , express = require('express')
+            *      , app = express();
+            *
+            *    http.createServer(app).listen(80);
+            *    https.createServer({ ... }, app).listen(443);
+            */
+        listen(port: number, hostname: string, backlog: number, callback?: Function): http.Server;
+        listen(port: number, hostname: string, callback?: Function): http.Server;
+        listen(port: number, callback?: Function): http.Server;
+        listen(path: string, callback?: Function): http.Server;
+        listen(handle: any, listeningListener?: Function): http.Server;
+
+        route(path: string): IRoute;
+
+        router: string;
+
+        settings: any;
+
+        resource: any;
+
+        map: any;
+
+        locals: any;
+
+        /**
+            * The app.routes object houses all of the routes defined mapped by the
+            * associated HTTP verb. This object may be used for introspection
+            * capabilities, for example Express uses this internally not only for
+            * routing but to provide default OPTIONS behaviour unless app.options()
+            * is used. Your application or framework may also remove routes by
+            * simply by removing them from this object.
+            */
+        routes: any;
+    }
+
+    interface Express extends Application {
+        /**
+            * Framework version.
+            */
+        version: string;
+
+        /**
+            * Expose mime.
+            */
+        mime: string;
+
+        (): Application;
+
+        /**
+        * Create an express application.
+        */
+        createApplication(): Application;
+
+        createServer(): Application;
+
+        application: any;
+
+        request: Request;
+
+        response: Response;
+    }
+
+    interface RequestHandler {
+        (req: Request, res: Response, next: NextFunction): any;
+    }
+}
\ No newline at end of file
diff --git a/express/express.d.ts b/express/express.d.ts
index 3404ce903..aedbc3851 100644
--- a/express/express.d.ts
+++ b/express/express.d.ts
@@ -10,1071 +10,44 @@
 
  =============================================== */
 
-/// <reference path="../node/node.d.ts" />
 /// <reference path="../serve-static/serve-static.d.ts" />
-
-declare module Express {
-
-    // These open interfaces may be extended in an application-specific manner via declaration merging.
-    // See for example method-override.d.ts (https://github.com/borisyankov/DefinitelyTyped/blob/master/method-override/method-override.d.ts)
-    export interface Request { }
-    export interface Response { }
-    export interface Application { }
-}
-
+/// <reference path="../express-serve-static-core/express-serve-static-core.d.ts" />
 
 declare module "express" {
-    import * as http from "http";
     import * as serveStatic from "serve-static";
+    import * as core from "express-serve-static-core";
 
-    function e(): e.Express;
+    /**
+     * Creates an Express application. The express() function is a top-level function exported by the express module.
+     */
+    function e(): core.Express;
 
     module e {
-        interface IRoute {
-            path: string;
-            stack: any;
-            all(...handler: RequestHandler[]): IRoute;
-            get(...handler: RequestHandler[]): IRoute;
-            post(...handler: RequestHandler[]): IRoute;
-            put(...handler: RequestHandler[]): IRoute;
-            delete(...handler: RequestHandler[]): IRoute;
-            patch(...handler: RequestHandler[]): IRoute;
-            options(...handler: RequestHandler[]): IRoute;
-            head(...handler: RequestHandler[]): IRoute;
-        }
-
-        interface IRouterMatcher<T> {
-            (name: string|RegExp, ...handlers: RequestHandler[]): T;
-        }
-
-        interface IRouter<T> extends RequestHandler {
-            /**
-             * Map the given param placeholder `name`(s) to the given callback(s).
-             *
-             * Parameter mapping is used to provide pre-conditions to routes
-             * which use normalized placeholders. For example a _:user_id_ parameter
-             * could automatically load a user's information from the database without
-             * any additional code,
-             *
-             * The callback uses the samesignature as middleware, the only differencing
-             * being that the value of the placeholder is passed, in this case the _id_
-             * of the user. Once the `next()` function is invoked, just like middleware
-             * it will continue on to execute the route, or subsequent parameter functions.
-             *
-             *      app.param('user_id', function(req, res, next, id){
-             *        User.find(id, function(err, user){
-             *          if (err) {
-             *            next(err);
-             *          } else if (user) {
-             *            req.user = user;
-             *            next();
-             *          } else {
-             *            next(new Error('failed to load user'));
-             *          }
-             *        });
-             *      });
-             *
-             * @param name
-             * @param fn
-             */
-            param(name: string, handler: RequestParamHandler): T;
-            param(name: string, matcher: RegExp): T;
-            param(name: string, mapper: (param: any) => any): T;
-            // Alternatively, you can pass only a callback, in which case you have the opportunity to alter the app.param() API
-            param(callback: (name: string, matcher: RegExp) => RequestParamHandler): T;
-
-            /**
-             * Special-cased "all" method, applying the given route `path`,
-             * middleware, and callback to _every_ HTTP method.
-             *
-             * @param path
-             * @param fn
-             */
-            all: IRouterMatcher<T>;
-            get: IRouterMatcher<T>;
-            post: IRouterMatcher<T>;
-            put: IRouterMatcher<T>;
-            delete: IRouterMatcher<T>;
-            patch: IRouterMatcher<T>;
-            options: IRouterMatcher<T>;
-            head: IRouterMatcher<T>;
-
-            route(path: string): IRoute;
-
-            use(...handler: RequestHandler[]): T;
-            use(handler: ErrorRequestHandler|RequestHandler): T;
-            use(path: string, ...handler: RequestHandler[]): T;
-            use(path: string, handler: ErrorRequestHandler|RequestHandler): T;
-            use(path: string[], ...handler: RequestHandler[]): T;
-            use(path: string[], handler: ErrorRequestHandler): T;
-            use(path: RegExp, ...handler: RequestHandler[]): T;
-            use(path: RegExp, handler: ErrorRequestHandler): T;
-            use(path:string, router:Router): T;
-        }
-
-        export function Router(options?: any): Router;
-
-        export interface Router extends IRouter<Router> {}
-
-        interface CookieOptions {
-            maxAge?: number;
-            signed?: boolean;
-            expires?: Date;
-            httpOnly?: boolean;
-            path?: string;
-            domain?: string;
-            secure?: boolean;
-        }
-
-        interface Errback { (err: Error): void; }
-
-        interface Request extends http.ServerRequest, Express.Request {
-
-            /**
-             * Return request header.
-             *
-             * The `Referrer` header field is special-cased,
-             * both `Referrer` and `Referer` are interchangeable.
-             *
-             * Examples:
-             *
-             *     req.get('Content-Type');
-             *     // => "text/plain"
-             *
-             *     req.get('content-type');
-             *     // => "text/plain"
-             *
-             *     req.get('Something');
-             *     // => undefined
-             *
-             * Aliased as `req.header()`.
-             *
-             * @param name
-             */
-            get (name: string): string;
-
-            header(name: string): string;
-
-            headers: { [key: string]: string; };
-
-            /**
-             * Check if the given `type(s)` is acceptable, returning
-             * the best match when true, otherwise `undefined`, in which
-             * case you should respond with 406 "Not Acceptable".
-             *
-             * The `type` value may be a single mime type string
-             * such as "application/json", the extension name
-             * such as "json", a comma-delimted list such as "json, html, text/plain",
-             * or an array `["json", "html", "text/plain"]`. When a list
-             * or array is given the _best_ match, if any is returned.
-             *
-             * Examples:
-             *
-             *     // Accept: text/html
-             *     req.accepts('html');
-             *     // => "html"
-             *
-             *     // Accept: text/*, application/json
-             *     req.accepts('html');
-             *     // => "html"
-             *     req.accepts('text/html');
-             *     // => "text/html"
-             *     req.accepts('json, text');
-             *     // => "json"
-             *     req.accepts('application/json');
-             *     // => "application/json"
-             *
-             *     // Accept: text/*, application/json
-             *     req.accepts('image/png');
-             *     req.accepts('png');
-             *     // => undefined
-             *
-             *     // Accept: text/*;q=.5, application/json
-             *     req.accepts(['html', 'json']);
-             *     req.accepts('html, json');
-             *     // => "json"
-             */
-            accepts(type: string): string;
-
-            accepts(type: string[]): string;
-
-            /**
-             * Returns the first accepted charset of the specified character sets,
-             * based on the request’s Accept-Charset HTTP header field.
-             * If none of the specified charsets is accepted, returns false.
-             *
-             * For more information, or if you have issues or concerns, see accepts.
-             * @param charset
-             */
-            acceptsCharsets(charset?: string|string[]): string[];
-
-            /**
-             * Returns the first accepted encoding of the specified encodings,
-             * based on the request’s Accept-Encoding HTTP header field.
-             * If none of the specified encodings is accepted, returns false.
-             *
-             * For more information, or if you have issues or concerns, see accepts.
-             * @param encoding
-             */
-            acceptsEncodings(encoding?: string|string[]): string[];
-
-            /**
-             * Returns the first accepted language of the specified languages,
-             * based on the request’s Accept-Language HTTP header field.
-             * If none of the specified languages is accepted, returns false.
-             *
-             * For more information, or if you have issues or concerns, see accepts.
-             *
-             * @param lang
-             */
-            acceptsLanguages(lang?: string|string[]): string[];
-
-            /**
-             * Parse Range header field,
-             * capping to the given `size`.
-             *
-             * Unspecified ranges such as "0-" require
-             * knowledge of your resource length. In
-             * the case of a byte range this is of course
-             * the total number of bytes. If the Range
-             * header field is not given `null` is returned,
-             * `-1` when unsatisfiable, `-2` when syntactically invalid.
-             *
-             * NOTE: remember that ranges are inclusive, so
-             * for example "Range: users=0-3" should respond
-             * with 4 users when available, not 3.
-             *
-             * @param size
-             */
-            range(size: number): any[];
-
-            /**
-             * Return an array of Accepted media types
-             * ordered from highest quality to lowest.
-             */
-            accepted: MediaType[];
-
-            /**
-             * Return the value of param `name` when present or `defaultValue`.
-             *
-             *  - Checks route placeholders, ex: _/user/:id_
-             *  - Checks body params, ex: id=12, {"id":12}
-             *  - Checks query string params, ex: ?id=12
-             *
-             * To utilize request bodies, `req.body`
-             * should be an object. This can be done by using
-             * the `connect.bodyParser()` middleware.
-             *
-             * @param name
-             * @param defaultValue
-             */
-            param(name: string, defaultValue?: any): string;
-
-            /**
-             * Check if the incoming request contains the "Content-Type"
-             * header field, and it contains the give mime `type`.
-             *
-             * Examples:
-             *
-             *      // With Content-Type: text/html; charset=utf-8
-             *      req.is('html');
-             *      req.is('text/html');
-             *      req.is('text/*');
-             *      // => true
-             *
-             *      // When Content-Type is application/json
-             *      req.is('json');
-             *      req.is('application/json');
-             *      req.is('application/*');
-             *      // => true
-             *
-             *      req.is('html');
-             *      // => false
-             *
-             * @param type
-             */
-            is(type: string): boolean;
-
-            /**
-             * Return the protocol string "http" or "https"
-             * when requested with TLS. When the "trust proxy"
-             * setting is enabled the "X-Forwarded-Proto" header
-             * field will be trusted. If you're running behind
-             * a reverse proxy that supplies https for you this
-             * may be enabled.
-             */
-            protocol: string;
-
-            /**
-             * Short-hand for:
-             *
-             *    req.protocol == 'https'
-             */
-            secure: boolean;
-
-            /**
-             * Return the remote address, or when
-             * "trust proxy" is `true` return
-             * the upstream addr.
-             */
-            ip: string;
-
-            /**
-             * When "trust proxy" is `true`, parse
-             * the "X-Forwarded-For" ip address list.
-             *
-             * For example if the value were "client, proxy1, proxy2"
-             * you would receive the array `["client", "proxy1", "proxy2"]`
-             * where "proxy2" is the furthest down-stream.
-             */
-            ips: string[];
-
-            /**
-             * Return subdomains as an array.
-             *
-             * Subdomains are the dot-separated parts of the host before the main domain of
-             * the app. By default, the domain of the app is assumed to be the last two
-             * parts of the host. This can be changed by setting "subdomain offset".
-             *
-             * For example, if the domain is "tobi.ferrets.example.com":
-             * If "subdomain offset" is not set, req.subdomains is `["ferrets", "tobi"]`.
-             * If "subdomain offset" is 3, req.subdomains is `["tobi"]`.
-             */
-            subdomains: string[];
-
-            /**
-             * Short-hand for `url.parse(req.url).pathname`.
-             */
-            path: string;
-
-            /**
-             * Parse the "Host" header field hostname.
-             */
-            hostname: string;
-
-            /**
-             * @deprecated Use hostname instead.
-             */
-            host: string;
-
-            /**
-             * Check if the request is fresh, aka
-             * Last-Modified and/or the ETag
-             * still match.
-             */
-            fresh: boolean;
-
-            /**
-             * Check if the request is stale, aka
-             * "Last-Modified" and / or the "ETag" for the
-             * resource has changed.
-             */
-            stale: boolean;
-
-            /**
-             * Check if the request was an _XMLHttpRequest_.
-             */
-            xhr: boolean;
-
-            //body: { username: string; password: string; remember: boolean; title: string; };
-            body: any;
-
-            //cookies: { string; remember: boolean; };
-            cookies: any;
-
-            method: string;
-
-            params: any;
-
-            user: any;
-
-            authenticatedUser: any;
-
-            /**
-             * Clear cookie `name`.
-             *
-             * @param name
-             * @param options
-             */
-            clearCookie(name: string, options?: any): Response;
-
-            query: any;
-
-            route: any;
-
-            signedCookies: any;
-
-            originalUrl: string;
-
-            url: string;
-
-            baseUrl: string;
-
-            app: Application;
-        }
-
-        interface MediaType {
-            value: string;
-            quality: number;
-            type: string;
-            subtype:  string;
-        }
-
-        interface Send {
-            (status: number, body?: any): Response;
-            (body: any): Response;
-        }
-
-        interface Response extends http.ServerResponse, Express.Response {
-            /**
-             * Set status `code`.
-             *
-             * @param code
-             */
-            status(code: number): Response;
-
-            /**
-             * Set the response HTTP status code to `statusCode` and send its string representation as the response body.
-             * @link http://expressjs.com/4x/api.html#res.sendStatus
-             *
-             * Examples:
-             *
-             *    res.sendStatus(200); // equivalent to res.status(200).send('OK')
-             *    res.sendStatus(403); // equivalent to res.status(403).send('Forbidden')
-             *    res.sendStatus(404); // equivalent to res.status(404).send('Not Found')
-             *    res.sendStatus(500); // equivalent to res.status(500).send('Internal Server Error')
-             *
-             * @param code
-             */
-            sendStatus(code: number): Response;
-
-            /**
-             * Set Link header field with the given `links`.
-             *
-             * Examples:
-             *
-             *    res.links({
-             *      next: 'http://api.example.com/users?page=2',
-             *      last: 'http://api.example.com/users?page=5'
-             *    });
-             *
-             * @param links
-             */
-            links(links: any): Response;
-
-            /**
-             * Send a response.
-             *
-             * Examples:
-             *
-             *     res.send(new Buffer('wahoo'));
-             *     res.send({ some: 'json' });
-             *     res.send('<p>some html</p>');
-             *     res.send(404, 'Sorry, cant find that');
-             *     res.send(404);
-             */
-            send: Send;
-
-            /**
-             * Send JSON response.
-             *
-             * Examples:
-             *
-             *     res.json(null);
-             *     res.json({ user: 'tj' });
-             *     res.json(500, 'oh noes!');
-             *     res.json(404, 'I dont have that');
-             */
-            json: Send;
-
-            /**
-             * Send JSON response with JSONP callback support.
-             *
-             * Examples:
-             *
-             *     res.jsonp(null);
-             *     res.jsonp({ user: 'tj' });
-             *     res.jsonp(500, 'oh noes!');
-             *     res.jsonp(404, 'I dont have that');
-             */
-            jsonp: Send;
-
-            /**
-             * Transfer the file at the given `path`.
-             *
-             * Automatically sets the _Content-Type_ response header field.
-             * The callback `fn(err)` is invoked when the transfer is complete
-             * or when an error occurs. Be sure to check `res.sentHeader`
-             * if you wish to attempt responding, as the header and some data
-             * may have already been transferred.
-             *
-             * Options:
-             *
-             *   - `maxAge`   defaulting to 0 (can be string converted by `ms`)
-             *   - `root`     root directory for relative filenames
-             *   - `headers`  object of headers to serve with file
-             *   - `dotfiles` serve dotfiles, defaulting to false; can be `"allow"` to send them
-             *
-             * Other options are passed along to `send`.
-             *
-             * Examples:
-             *
-             *  The following example illustrates how `res.sendFile()` may
-             *  be used as an alternative for the `static()` middleware for
-             *  dynamic situations. The code backing `res.sendFile()` is actually
-             *  the same code, so HTTP cache support etc is identical.
-             *
-             *     app.get('/user/:uid/photos/:file', function(req, res){
-             *       var uid = req.params.uid
-             *         , file = req.params.file;
-             *
-             *       req.user.mayViewFilesFrom(uid, function(yes){
-             *         if (yes) {
-             *           res.sendFile('/uploads/' + uid + '/' + file);
-             *         } else {
-             *           res.send(403, 'Sorry! you cant see that.');
-             *         }
-             *       });
-             *     });
-             *
-             * @api public
-             */
-            sendFile(path: string): void;
-            sendFile(path: string, options: any): void;
-            sendFile(path: string, fn: Errback): void;
-            sendFile(path: string, options: any, fn: Errback): void;
-
-            /**
-             * @deprecated Use sendFile instead.
-             */
-            sendfile(path: string): void;
-            /**
-             * @deprecated Use sendFile instead.
-             */
-            sendfile(path: string, options: any): void;
-            /**
-             * @deprecated Use sendFile instead.
-             */
-            sendfile(path: string, fn: Errback): void;
-            /**
-             * @deprecated Use sendFile instead.
-             */
-            sendfile(path: string, options: any, fn: Errback): void;
-
-            /**
-             * Transfer the file at the given `path` as an attachment.
-             *
-             * Optionally providing an alternate attachment `filename`,
-             * and optional callback `fn(err)`. The callback is invoked
-             * when the data transfer is complete, or when an error has
-             * ocurred. Be sure to check `res.headerSent` if you plan to respond.
-             *
-             * This method uses `res.sendfile()`.
-             */
-            download(path: string): void;
-            download(path: string, filename: string): void;
-            download(path: string, fn: Errback): void;
-            download(path: string, filename: string, fn: Errback): void;
-
-            /**
-             * Set _Content-Type_ response header with `type` through `mime.lookup()`
-             * when it does not contain "/", or set the Content-Type to `type` otherwise.
-             *
-             * Examples:
-             *
-             *     res.type('.html');
-             *     res.type('html');
-             *     res.type('json');
-             *     res.type('application/json');
-             *     res.type('png');
-             *
-             * @param type
-             */
-            contentType(type: string): Response;
-
-            /**
-             * Set _Content-Type_ response header with `type` through `mime.lookup()`
-             * when it does not contain "/", or set the Content-Type to `type` otherwise.
-             *
-             * Examples:
-             *
-             *     res.type('.html');
-             *     res.type('html');
-             *     res.type('json');
-             *     res.type('application/json');
-             *     res.type('png');
-             *
-             * @param type
-             */
-            type(type: string): Response;
-
-            /**
-             * Respond to the Acceptable formats using an `obj`
-             * of mime-type callbacks.
-             *
-             * This method uses `req.accepted`, an array of
-             * acceptable types ordered by their quality values.
-             * When "Accept" is not present the _first_ callback
-             * is invoked, otherwise the first match is used. When
-             * no match is performed the server responds with
-             * 406 "Not Acceptable".
-             *
-             * Content-Type is set for you, however if you choose
-             * you may alter this within the callback using `res.type()`
-             * or `res.set('Content-Type', ...)`.
-             *
-             *    res.format({
-             *      'text/plain': function(){
-             *        res.send('hey');
-             *      },
-             *
-             *      'text/html': function(){
-             *        res.send('<p>hey</p>');
-             *      },
-             *
-             *      'appliation/json': function(){
-             *        res.send({ message: 'hey' });
-             *      }
-             *    });
-             *
-             * In addition to canonicalized MIME types you may
-             * also use extnames mapped to these types:
-             *
-             *    res.format({
-             *      text: function(){
-             *        res.send('hey');
-             *      },
-             *
-             *      html: function(){
-             *        res.send('<p>hey</p>');
-             *      },
-             *
-             *      json: function(){
-             *        res.send({ message: 'hey' });
-             *      }
-             *    });
-             *
-             * By default Express passes an `Error`
-             * with a `.status` of 406 to `next(err)`
-             * if a match is not made. If you provide
-             * a `.default` callback it will be invoked
-             * instead.
-             *
-             * @param obj
-             */
-            format(obj: any): Response;
-
-            /**
-             * Set _Content-Disposition_ header to _attachment_ with optional `filename`.
-             *
-             * @param filename
-             */
-            attachment(filename?: string): Response;
-
-            /**
-             * Set header `field` to `val`, or pass
-             * an object of header fields.
-             *
-             * Examples:
-             *
-             *    res.set('Foo', ['bar', 'baz']);
-             *    res.set('Accept', 'application/json');
-             *    res.set({ Accept: 'text/plain', 'X-API-Key': 'tobi' });
-             *
-             * Aliased as `res.header()`.
-             */
-            set(field: any): Response;
-            set(field: string, value?: string): Response;
-
-            header(field: any): Response;
-            header(field: string, value?: string): Response;
-
-            // Property indicating if HTTP headers has been sent for the response.
-            headersSent: boolean;
-
-            /**
-             * Get value for header `field`.
-             *
-             * @param field
-             */
-            get (field: string): string;
-
-            /**
-             * Clear cookie `name`.
-             *
-             * @param name
-             * @param options
-             */
-            clearCookie(name: string, options?: any): Response;
-
-            /**
-             * Set cookie `name` to `val`, with the given `options`.
-             *
-             * Options:
-             *
-             *    - `maxAge`   max-age in milliseconds, converted to `expires`
-             *    - `signed`   sign the cookie
-             *    - `path`     defaults to "/"
-             *
-             * Examples:
-             *
-             *    // "Remember Me" for 15 minutes
-             *    res.cookie('rememberme', '1', { expires: new Date(Date.now() + 900000), httpOnly: true });
-             *
-             *    // save as above
-             *    res.cookie('rememberme', '1', { maxAge: 900000, httpOnly: true })
-             */
-            cookie(name: string, val: string, options: CookieOptions): Response;
-            cookie(name: string, val: any, options: CookieOptions): Response;
-            cookie(name: string, val: any): Response;
-
-            /**
-             * Set the location header to `url`.
-             *
-             * The given `url` can also be the name of a mapped url, for
-             * example by default express supports "back" which redirects
-             * to the _Referrer_ or _Referer_ headers or "/".
-             *
-             * Examples:
-             *
-             *    res.location('/foo/bar').;
-             *    res.location('http://example.com');
-             *    res.location('../login'); // /blog/post/1 -> /blog/login
-             *
-             * Mounting:
-             *
-             *   When an application is mounted and `res.location()`
-             *   is given a path that does _not_ lead with "/" it becomes
-             *   relative to the mount-point. For example if the application
-             *   is mounted at "/blog", the following would become "/blog/login".
-             *
-             *      res.location('login');
-             *
-             *   While the leading slash would result in a location of "/login":
-             *
-             *      res.location('/login');
-             *
-             * @param url
-             */
-            location(url: string): Response;
-
-            /**
-             * Redirect to the given `url` with optional response `status`
-             * defaulting to 302.
-             *
-             * The resulting `url` is determined by `res.location()`, so
-             * it will play nicely with mounted apps, relative paths,
-             * `"back"` etc.
-             *
-             * Examples:
-             *
-             *    res.redirect('/foo/bar');
-             *    res.redirect('http://example.com');
-             *    res.redirect(301, 'http://example.com');
-             *    res.redirect('http://example.com', 301);
-             *    res.redirect('../login'); // /blog/post/1 -> /blog/login
-             */
-            redirect(url: string): void;
-            redirect(status: number, url: string): void;
-            redirect(url: string, status: number): void;
-
-            /**
-             * Render `view` with the given `options` and optional callback `fn`.
-             * When a callback function is given a response will _not_ be made
-             * automatically, otherwise a response of _200_ and _text/html_ is given.
-             *
-             * Options:
-             *
-             *  - `cache`     boolean hinting to the engine it should cache
-             *  - `filename`  filename of the view being rendered
-             */
-            render(view: string, options?: Object, callback?: (err: Error, html: string) => void ): void;
-            render(view: string, callback?: (err: Error, html: string) => void ): void;
-
-            locals: any;
-
-            charset: string;
-        }
-
-        interface NextFunction {
-            (): void;
-            (err: any): void;
-        }
-
-        interface ErrorRequestHandler {
-            (err: any, req: Request, res: Response, next: NextFunction): any;
-        }
-
-        interface RequestHandler {
-            (req: Request, res: Response, next: NextFunction): any;
-        }
-
-        interface Handler extends RequestHandler {}
-
-        interface RequestParamHandler {
-            (req: Request, res: Response, next: NextFunction, param: any): any;
-        }
-
-        interface Application extends IRouter<Application>, Express.Application {
-            /**
-             * Initialize the server.
-             *
-             *   - setup default configuration
-             *   - setup default middleware
-             *   - setup route reflection methods
-             */
-            init(): void;
-
-            /**
-             * Initialize application configuration.
-             */
-            defaultConfiguration(): void;
-
-            /**
-             * Register the given template engine callback `fn`
-             * as `ext`.
-             *
-             * By default will `require()` the engine based on the
-             * file extension. For example if you try to render
-             * a "foo.jade" file Express will invoke the following internally:
-             *
-             *     app.engine('jade', require('jade').__express);
-             *
-             * For engines that do not provide `.__express` out of the box,
-             * or if you wish to "map" a different extension to the template engine
-             * you may use this method. For example mapping the EJS template engine to
-             * ".html" files:
-             *
-             *     app.engine('html', require('ejs').renderFile);
-             *
-             * In this case EJS provides a `.renderFile()` method with
-             * the same signature that Express expects: `(path, options, callback)`,
-             * though note that it aliases this method as `ejs.__express` internally
-             * so if you're using ".ejs" extensions you dont need to do anything.
-             *
-             * Some template engines do not follow this convention, the
-             * [Consolidate.js](https://github.com/visionmedia/consolidate.js)
-             * library was created to map all of node's popular template
-             * engines to follow this convention, thus allowing them to
-             * work seamlessly within Express.
-             */
-            engine(ext: string, fn: Function): Application;
-
-            /**
-             * Assign `setting` to `val`, or return `setting`'s value.
-             *
-             *    app.set('foo', 'bar');
-             *    app.get('foo');
-             *    // => "bar"
-             *    app.set('foo', ['bar', 'baz']);
-             *    app.get('foo');
-             *    // => ["bar", "baz"]
-             *
-             * Mounted servers inherit their parent server's settings.
-             *
-             * @param setting
-             * @param val
-             */
-            set(setting: string, val: any): Application;
-            get: {
-                (name: string): any; // Getter
-                (name: string|RegExp, ...handlers: RequestHandler[]): Application;
-            };
-
-            /**
-             * Return the app's absolute pathname
-             * based on the parent(s) that have
-             * mounted it.
-             *
-             * For example if the application was
-             * mounted as "/admin", which itself
-             * was mounted as "/blog" then the
-             * return value would be "/blog/admin".
-             */
-            path(): string;
-
-            /**
-             * Check if `setting` is enabled (truthy).
-             *
-             *    app.enabled('foo')
-             *    // => false
-             *
-             *    app.enable('foo')
-             *    app.enabled('foo')
-             *    // => true
-             */
-            enabled(setting: string): boolean;
-
-            /**
-             * Check if `setting` is disabled.
-             *
-             *    app.disabled('foo')
-             *    // => true
-             *
-             *    app.enable('foo')
-             *    app.disabled('foo')
-             *    // => false
-             *
-             * @param setting
-             */
-            disabled(setting: string): boolean;
-
-            /**
-             * Enable `setting`.
-             *
-             * @param setting
-             */
-            enable(setting: string): Application;
-
-            /**
-             * Disable `setting`.
-             *
-             * @param setting
-             */
-            disable(setting: string): Application;
-
-            /**
-             * Configure callback for zero or more envs,
-             * when no `env` is specified that callback will
-             * be invoked for all environments. Any combination
-             * can be used multiple times, in any order desired.
-             *
-             * Examples:
-             *
-             *    app.configure(function(){
-             *      // executed for all envs
-             *    });
-             *
-             *    app.configure('stage', function(){
-             *      // executed staging env
-             *    });
-             *
-             *    app.configure('stage', 'production', function(){
-             *      // executed for stage and production
-             *    });
-             *
-             * Note:
-             *
-             *  These callbacks are invoked immediately, and
-             *  are effectively sugar for the following:
-             *
-             *     var env = process.env.NODE_ENV || 'development';
-             *
-             *      switch (env) {
-             *        case 'development':
-             *          ...
-             *          break;
-             *        case 'stage':
-             *          ...
-             *          break;
-             *        case 'production':
-             *          ...
-             *          break;
-             *      }
-             *
-             * @param env
-             * @param fn
-             */
-            configure(fn: Function): Application;
-            configure(env0: string, fn: Function): Application;
-            configure(env0: string, env1: string, fn: Function): Application;
-            configure(env0: string, env1: string, env2: string, fn: Function): Application;
-            configure(env0: string, env1: string, env2: string, env3: string, fn: Function): Application;
-            configure(env0: string, env1: string, env2: string, env3: string, env4: string, fn: Function): Application;
-
-            /**
-             * Render the given view `name` name with `options`
-             * and a callback accepting an error and the
-             * rendered template string.
-             *
-             * Example:
-             *
-             *    app.render('email', { name: 'Tobi' }, function(err, html){
-             *      // ...
-             *    })
-             *
-             * @param name
-             * @param options or fn
-             * @param fn
-             */
-            render(name: string, options?: Object, callback?: (err: Error, html: string) => void): void;
-            render(name: string, callback: (err: Error, html: string) => void): void;
-
-
-            /**
-             * Listen for connections.
-             *
-             * A node `http.Server` is returned, with this
-             * application (which is a `Function`) as its
-             * callback. If you wish to create both an HTTP
-             * and HTTPS server you may do so with the "http"
-             * and "https" modules as shown here:
-             *
-             *    var http = require('http')
-             *      , https = require('https')
-             *      , express = require('express')
-             *      , app = express();
-             *
-             *    http.createServer(app).listen(80);
-             *    https.createServer({ ... }, app).listen(443);
-             */
-            listen(port: number, hostname: string, backlog: number, callback?: Function): http.Server;
-            listen(port: number, hostname: string, callback?: Function): http.Server;
-            listen(port: number, callback?: Function): http.Server;
-            listen(path: string, callback?: Function): http.Server;
-            listen(handle: any, listeningListener?: Function): http.Server;
-
-            route(path: string): IRoute;
-
-            router: string;
-
-            settings: any;
-
-            resource: any;
-
-            map: any;
-
-            locals: any;
-
-            /**
-             * The app.routes object houses all of the routes defined mapped by the
-             * associated HTTP verb. This object may be used for introspection
-             * capabilities, for example Express uses this internally not only for
-             * routing but to provide default OPTIONS behaviour unless app.options()
-             * is used. Your application or framework may also remove routes by
-             * simply by removing them from this object.
-             */
-            routes: any;
-        }
-
-        interface Express extends Application {
-            /**
-             * Framework version.
-             */
-            version: string;
-
-            /**
-             * Expose mime.
-             */
-            mime: string;
-
-            (): Application;
-
-            /**
-            * Create an express application.
-            */
-            createApplication(): Application;
-
-            createServer(): Application;
-
-            application: any;
-
-            request: Request;
-
-            response: Response;
-        }
 
+        /**
+         * This is the only built-in middleware function in Express. It serves static files and is based on serve-static.
+         */
         var static: typeof serveStatic;
+
+        export function Router(options?: any): core.Router;
+
+        interface Application extends core.Application { }
+        interface CookieOptions extends core.CookieOptions { }
+        interface Errback extends core.Errback { }
+        interface ErrorRequestHandler extends core.ErrorRequestHandler { }
+        interface Express extends core.Express { }
+        interface Handler extends core.Handler { }
+        interface IRoute extends core.IRoute { }
+        interface IRouter<T> extends core.IRouter<T> { }
+        interface IRouterMatcher<T> extends core.IRouterMatcher<T> { }
+        interface MediaType extends core.MediaType { }
+        interface NextFunction extends core.NextFunction { }
+        interface Request extends core.Request { }
+        interface RequestHandler extends core.RequestHandler { }
+        interface RequestParamHandler extends core.RequestParamHandler { }
+        export interface Response extends core.Response { }
+        interface Router extends core.Router { }
+        interface Send extends core.Send { }
     }
 
     export = e;
diff --git a/fixed-data-table/fixed-data-table-0.4.7.d.ts b/fixed-data-table/fixed-data-table-0.4.7.d.ts
index 1dc22dc3d..f681e5ea5 100644
--- a/fixed-data-table/fixed-data-table-0.4.7.d.ts
+++ b/fixed-data-table/fixed-data-table-0.4.7.d.ts
@@ -387,16 +387,13 @@ declare module FixedDataTable {
     }
 
     export class Table extends __React.Component<TableProps, {}> {
-         render(): __React.DOMElement<any>
     }
     export class Column extends __React.Component<ColumnProps, {}> {
-         render(): __React.DOMElement<any>
     }
     export class ColumnGroup extends __React.Component<ColumnGroupProps, {}> {
-         render(): __React.DOMElement<any>
     }
 }
 
 declare module "fixed-data-table" {    
     export = FixedDataTable;
-}
\ No newline at end of file
+}
diff --git a/fixed-data-table/fixed-data-table.d.ts b/fixed-data-table/fixed-data-table.d.ts
index 843eb458e..c561abf41 100644
--- a/fixed-data-table/fixed-data-table.d.ts
+++ b/fixed-data-table/fixed-data-table.d.ts
@@ -483,16 +483,12 @@ declare module FixedDataTable {
     }
 
     export class Table extends __React.Component<TableProps, {}> {
-         render(): __React.DOMElement<any>
     }
     export class Column extends __React.Component<ColumnProps, {}> {
-         render(): __React.DOMElement<any>
     }
     export class ColumnGroup extends __React.Component<ColumnGroupProps, {}> {
-         render(): __React.DOMElement<any>
     }
     export class Cell extends __React.Component<CellProps, {}> {
-         render(): __React.DOMElement<any>
     }
 }
 
diff --git a/google.visualization/google.visualization.d.ts b/google.visualization/google.visualization.d.ts
index 45a230fee..e3312c2e8 100644
--- a/google.visualization/google.visualization.d.ts
+++ b/google.visualization/google.visualization.d.ts
@@ -444,6 +444,12 @@ declare module google {
             row?: number;
         }
 
+        export interface Candlestick {
+            hollowIsRising?: boolean;
+            fallingColor?: ChartStroke;
+            risingColor?: ChartStroke;
+        }
+
         class ChartBase {
             constructor(element: Element);
             getSelection(): VisualizationSelectionArray[];
@@ -1024,11 +1030,7 @@ declare module google {
             axisTitlesPosition?: string;
             backgroundColor?: any;
             bar?: GroupWidth;
-            candlestick?: {
-                hollowIsRising?: boolean;
-                fallingColor?: ChartStroke;
-                risingColor?: ChartStroke;
-            }
+            candlestick?: Candlestick;
             chartArea?: ChartArea;
             colors?: string[];
             enableInteractivity?: boolean;
@@ -1052,6 +1054,60 @@ declare module google {
             width?: number;
         }
 
+        //#endregion
+        //#region ComboChart
+
+        // https://google-developers.appspot.com/chart/interactive/docs/gallery/combochart
+        export class ComboChart extends CoreChartBase {
+            draw(data: DataTable, options: ComboChartOptions): void;
+            draw(data: DataView, options: ComboChartOptions): void;
+        }
+
+        // https://google-developers.appspot.com/chart/interactive/docs/gallery/combochart#configuration-options
+        export interface ComboChartOptions {
+            aggregationTarget?: string;
+            animation?: TransitionAnimation;
+            annotations?: ChartAnnotations;
+            areaOpacity?: number;
+            axisTitlesPosition?: string; // in, out, none
+            backgroundColor?: any;
+            bar?: GroupWidth;
+            candlestick?: Candlestick;
+            chartArea?: ChartArea;
+            colors?: string[];
+            crosshair?: ChartCrosshair;
+            curveType?: string;
+            dataOpacity?: number;
+            enableInteractivity?: boolean;
+            focusTarget?: string;
+            fontSize?: number;
+            fontName?: string;
+            forceIFrame?: boolean;
+            hAxis?: ChartAxis;
+            height?: number;
+            interpolateNulls?: boolean;
+            isStacked?: boolean;
+            legend?: ChartLegend;
+            lineDashStyle?: number[];
+            lineWidth?: number;
+            orientation?: string;
+            pointShape?: string;
+            pointSize?: number;
+            pointsVisible?: boolean;
+            reverseCategories?: boolean;
+            selectionMode?: string;// single / multiple
+            series?: any;
+            seriesType?: string;
+            theme?: string;
+            title?: string;
+            titlePosition?: string;
+            titleTextStyle?: ChartTextStyle;
+            tooltip?: ChartTooltip;
+            vAxes?: any;
+            vAxis?: ChartAxis;
+            width?: number;
+        }
+
         //#endregion
         //#region Events
 
diff --git a/harmony-proxy/harmony-proxy-tests.ts b/harmony-proxy/harmony-proxy-tests.ts
new file mode 100644
index 000000000..4c011d5fd
--- /dev/null
+++ b/harmony-proxy/harmony-proxy-tests.ts
@@ -0,0 +1,27 @@
+/// <reference path="./harmony-proxy.d.ts" />
+
+import * as Proxy from "harmony-proxy";
+
+interface IKatana {
+    use: () => void;
+}
+
+class Katana implements IKatana {
+    public use() {
+        console.log("Used Katana!");
+    }
+}
+
+let handler = {
+    apply: function(target: any, thisArg: any, argArray: any) {
+        console.log(`Starting: ${performance.now()}`);
+        let result = target.apply(thisArg, argArray);
+        console.log(`Finished: ${performance.now()}`);
+        return result;
+    }
+};
+
+let katana = new Katana();
+
+let katanaProxy =  new Proxy<IKatana>(katana, handler);
+katanaProxy.use();
diff --git a/harmony-proxy/harmony-proxy.d.ts b/harmony-proxy/harmony-proxy.d.ts
new file mode 100644
index 000000000..dba832c14
--- /dev/null
+++ b/harmony-proxy/harmony-proxy.d.ts
@@ -0,0 +1,35 @@
+// Type definitions for harmony-proxy 1.0.0
+// Project: https://www.npmjs.com/package/harmony-proxy
+// Definitions by: Remo Jansen <https://github.com/remojansen/>
+// Definitions: https://github.com/borisyankov/DefinitelyTyped
+
+declare module harmonyProxy {
+    type PropertyKey = string | number | symbol;
+
+    interface ProxyHandler<T> {
+        getPrototypeOf? (target: T): any;
+        setPrototypeOf? (target: T, v: any): boolean;
+        isExtensible? (target: T): boolean;
+        preventExtensions? (target: T): boolean;
+        getOwnPropertyDescriptor? (target: T, p: PropertyKey): PropertyDescriptor;
+        has? (target: T, p: PropertyKey): boolean;
+        get? (target: T, p: PropertyKey, receiver: any): any;
+        set? (target: T, p: PropertyKey, value: any, receiver: any): boolean;
+        deleteProperty? (target: T, p: PropertyKey): boolean;
+        defineProperty? (target: T, p: PropertyKey, attributes: PropertyDescriptor): boolean;
+        enumerate? (target: T): PropertyKey[];
+        ownKeys? (target: T): PropertyKey[];
+        apply? (target: T, thisArg: any, argArray?: any): any;
+        construct? (target: T, thisArg: any, argArray?: any): any;
+    }
+
+    interface ProxyConstructor {
+        revocable<T>(target: T, handler: ProxyHandler<T>): { proxy: T; revoke: () => void; };
+        new <T>(target: T, handler: ProxyHandler<T>): T
+    }
+}
+
+declare module "harmony-proxy" {
+    let _Proxy: harmonyProxy.ProxyConstructor;
+    export = _Proxy;
+}
diff --git a/howlerjs/howler.d.ts b/howlerjs/howler.d.ts
index b1265dc6b..8d2c38220 100644
--- a/howlerjs/howler.d.ts
+++ b/howlerjs/howler.d.ts
@@ -18,14 +18,21 @@ interface IHowlSoundSpriteDefinition {
     [name: string]: number[];
 }
 
+declare type HowlPos3d = [number, number, number]|[number, number, number, number];
+
 interface IHowlProperties {
     autoplay?: boolean;
     buffer?: boolean;
+    duration?: number;
     format?: string;
     loop?: boolean;
     sprite?: IHowlSoundSpriteDefinition;
+    src?: string;
+    pos3d?: HowlPos3d;
     volume?: number;
     urls?: string[];
+    rate?: number;
+    model?: 'equalpower'|'HRTF';
     onend?: Function;
     onload?: Function;
     onloaderror?: Function;
diff --git a/inversify/inversify-global-tests.ts b/inversify/inversify-global-tests.ts
new file mode 100644
index 000000000..ab1ac4b11
--- /dev/null
+++ b/inversify/inversify-global-tests.ts
@@ -0,0 +1,193 @@
+/// <reference path="inversify.d.ts" />
+
+module global_module_test {
+
+    interface INinja {
+        fight(): string;
+        sneak(): string;
+    }
+
+    interface IKatana {
+        hit(): string;
+    }
+
+    interface IShuriken {
+        throw(): string;
+    }
+
+    class Katana implements IKatana {
+        public hit() {
+            return "cut!";
+        }
+    }
+
+    class Shuriken implements IShuriken {
+        public throw() {
+            return "hit!";
+        }
+    }
+
+    @inversify.inject("IKatana", "IShuriken")
+    class Ninja implements INinja {
+
+        private _katana: IKatana;
+        private _shuriken: IShuriken;
+
+        public constructor(katana: IKatana, shuriken: IShuriken) {
+            this._katana = katana;
+            this._shuriken = shuriken;
+        }
+
+        public fight() { return this._katana.hit(); };
+        public sneak() { return this._shuriken.throw(); };
+
+    }
+
+    let kernel = new inversify.Kernel();
+    kernel.bind<INinja>("INinja").to(Ninja);
+    kernel.bind<IKatana>("IKatana").to(Katana);
+    kernel.bind<IShuriken>("IShuriken").to(Shuriken).inSingletonScope();
+
+    let ninja = kernel.get<INinja>("INinja");
+    console.log(ninja);
+
+    // Unbind
+    kernel.unbind("INinja");
+    kernel.unbindAll();
+
+    // Kernel modules
+    let module: inversify.IKernelModule = (k: inversify.IKernel) => {
+        k.bind<INinja>("INinja").to(Ninja);
+        k.bind<IKatana>("IKatana").to(Katana).inTransientScope();
+        k.bind<IShuriken>("IShuriken").to(Shuriken).inSingletonScope();
+    };
+
+    let options: inversify.IKernelOptions = {
+        middleware: [],
+        modules: [module]
+    };
+
+    kernel = new inversify.Kernel(options);
+    let ninja2 = kernel.get<INinja>("INinja");
+    console.log(ninja2);
+
+    // binding types
+    kernel.bind<IKatana>("IKatana").to(Katana);
+    kernel.bind<IKatana>("IKatana").toValue(new Katana());
+
+    kernel.bind<inversify.INewable<IKatana>>("IKatana").toConstructor<IKatana>(Katana);
+
+    kernel.bind<inversify.IFactory<IKatana>>("IKatana").toFactory<IKatana>((context) => {
+        return () => {
+            return kernel.get<IKatana>("IKatana");
+        };
+    });
+
+    kernel.bind<inversify.IFactory<IKatana>>("IKatana").toAutoFactory<IKatana>();
+
+    kernel.bind<inversify.IProvider<IKatana>>("IKatana").toProvider<IKatana>((context) => {
+        return () => {
+            return new Promise<IKatana>((resolve) => {
+                let katana = kernel.get<IKatana>("IKatana");
+                resolve(katana);
+            });
+        };
+    });
+
+    kernel.bind<IKatana>("IKatana").to(Katana).proxy((katanaToBeInjected: IKatana) => {
+        // BLOCK http://stackoverflow.com/questions/35906938/how-to-enable-harmony-proxies-in-gulp-mocha
+        /*
+        let handler = {
+            apply: function(target, thisArgument, argumentsList) {
+                console.log(`Starting: ${performance.now()}`);
+                let result = target.apply(thisArgument, argumentsList);
+                console.log(`Finished: ${performance.now()}`);
+                return result;
+            }
+        };
+        return new Proxy(katanaToBeInjected, handler);
+        */
+        return katanaToBeInjected;
+    });
+
+    interface IWeapon {}
+    interface ISamurai {
+        katana: IWeapon;
+        shuriken: IWeapon;
+    }
+
+    @inversify.inject("IWeapon", "IWeapon")
+    class Samurai implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @inversify.tagged("canThrow", false) katana: IWeapon,
+            @inversify.tagged("canThrow", true) shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<Samurai>("Samurai").to(Samurai);
+    kernel.bind<IWeapon>("IWeapon").to(Katana).whenTargetTagged("canThrow", false);
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).whenTargetTagged("canThrow", true);
+
+    let throwable = inversify.tagged("canThrow", true);
+    let notThrowable = inversify.tagged("canThrow", false);
+
+    @inversify.inject("IWeapon", "IWeapon")
+    class Samurai2 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @throwable("canThrow", false) katana: IWeapon,
+            @notThrowable("canThrow", true) shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    @inversify.inject("IWeapon", "IWeapon")
+    class Samurai3 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @inversify.named("strong") katana: IWeapon,
+            @inversify.named("weak") shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<ISamurai>("ISamurai").to(Samurai3);
+    kernel.bind<IWeapon>("IWeapon").to(Katana).whenTargetNamed("strong");
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).whenTargetNamed("weak");
+
+    @inversify.inject("IWeapon", "IWeapon")
+    @inversify.paramNames("katana", "shuriken")
+    class Samurai4 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            katana: IWeapon,
+            shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<ISamurai>("ISamurai").to(Samurai4);
+
+    kernel.bind<IWeapon>("IWeapon").to(Katana).when((request: inversify.IRequest) => {
+        return request.target.name.equals("katana");
+    });
+
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).when((request: inversify.IRequest) => {
+        return request.target.name.equals("shuriken");
+    });
+
+}
diff --git a/inversify/inversify-tests.ts b/inversify/inversify-tests.ts
index 46b5cab97..8d2d99d5c 100644
--- a/inversify/inversify-tests.ts
+++ b/inversify/inversify-tests.ts
@@ -1,75 +1,200 @@
 /// <reference path="inversify.d.ts" />
 
-interface FooInterface {
-  name : string;
-  greet() : string;
+import {
+    Kernel,
+    inject, tagged, named, paramNames,
+    IKernel, IKernelOptions, INewable,
+    IKernelModule, IFactory, IProvider, IRequest
+} from "inversify";
+
+module external_module_test {
+
+    interface INinja {
+        fight(): string;
+        sneak(): string;
+    }
+
+    interface IKatana {
+        hit(): string;
+    }
+
+    interface IShuriken {
+        throw(): string;
+    }
+
+    class Katana implements IKatana {
+        public hit() {
+            return "cut!";
+        }
+    }
+
+    class Shuriken implements IShuriken {
+        public throw() {
+            return "hit!";
+        }
+    }
+
+    @inject("IKatana", "IShuriken")
+    class Ninja implements INinja {
+
+        private _katana: IKatana;
+        private _shuriken: IShuriken;
+
+        public constructor(katana: IKatana, shuriken: IShuriken) {
+            this._katana = katana;
+            this._shuriken = shuriken;
+        }
+
+        public fight() { return this._katana.hit(); };
+        public sneak() { return this._shuriken.throw(); };
+
+    }
+
+    let kernel = new Kernel();
+    kernel.bind<INinja>("INinja").to(Ninja);
+    kernel.bind<IKatana>("IKatana").to(Katana);
+    kernel.bind<IShuriken>("IShuriken").to(Shuriken).inSingletonScope();
+
+    let ninja = kernel.get<INinja>("INinja");
+    console.log(ninja);
+
+    // Unbind
+    kernel.unbind("INinja");
+    kernel.unbindAll();
+
+    // Kernel modules
+    let module: IKernelModule = (k: IKernel) => {
+        k.bind<INinja>("INinja").to(Ninja);
+        k.bind<IKatana>("IKatana").to(Katana).inTransientScope();
+        k.bind<IShuriken>("IShuriken").to(Shuriken).inSingletonScope();
+    };
+
+    let options: IKernelOptions = {
+        middleware: [],
+        modules: [module]
+    };
+
+    kernel = new Kernel(options);
+    let ninja2 = kernel.get<INinja>("INinja");
+    console.log(ninja2);
+
+    // binding types
+    kernel.bind<IKatana>("IKatana").to(Katana);
+    kernel.bind<IKatana>("IKatana").toValue(new Katana());
+
+    kernel.bind<INewable<IKatana>>("IKatana").toConstructor<IKatana>(Katana);
+
+    kernel.bind<IFactory<IKatana>>("IKatana").toFactory<IKatana>((context) => {
+        return () => {
+            return kernel.get<IKatana>("IKatana");
+        };
+    });
+
+    kernel.bind<IFactory<IKatana>>("IKatana").toAutoFactory<IKatana>();
+
+    kernel.bind<IProvider<IKatana>>("IKatana").toProvider<IKatana>((context) => {
+        return () => {
+            return new Promise<IKatana>((resolve) => {
+                let katana = kernel.get<IKatana>("IKatana");
+                resolve(katana);
+            });
+        };
+    });
+
+    kernel.bind<IKatana>("IKatana").to(Katana).proxy((katanaToBeInjected: IKatana) => {
+        // BLOCK http://stackoverflow.com/questions/35906938/how-to-enable-harmony-proxies-in-gulp-mocha
+        /*
+        let handler = {
+            apply: function(target, thisArgument, argumentsList) {
+                console.log(`Starting: ${performance.now()}`);
+                let result = target.apply(thisArgument, argumentsList);
+                console.log(`Finished: ${performance.now()}`);
+                return result;
+            }
+        };
+        return new Proxy(katanaToBeInjected, handler);
+        */
+        return katanaToBeInjected;
+    });
+
+    interface IWeapon {}
+    interface ISamurai {
+        katana: IWeapon;
+        shuriken: IWeapon;
+    }
+
+    @inject("IWeapon", "IWeapon")
+    class Samurai implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @tagged("canThrow", false) katana: IWeapon,
+            @tagged("canThrow", true) shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<Samurai>("Samurai").to(Samurai);
+    kernel.bind<IWeapon>("IWeapon").to(Katana).whenTargetTagged("canThrow", false);
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).whenTargetTagged("canThrow", true);
+
+    let throwable = tagged("canThrow", true);
+    let notThrowable = tagged("canThrow", false);
+
+    @inject("IWeapon", "IWeapon")
+    class Samurai2 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @throwable("canThrow", false) katana: IWeapon,
+            @notThrowable("canThrow", true) shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    @inject("IWeapon", "IWeapon")
+    class Samurai3 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            @named("strong") katana: IWeapon,
+            @named("weak") shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<ISamurai>("ISamurai").to(Samurai3);
+    kernel.bind<IWeapon>("IWeapon").to(Katana).whenTargetNamed("strong");
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).whenTargetNamed("weak");
+
+    @inject("IWeapon", "IWeapon")
+    @paramNames("katana", "shuriken")
+    class Samurai4 implements ISamurai {
+        public katana: IWeapon;
+        public shuriken: IWeapon;
+        public constructor(
+            katana: IWeapon,
+            shuriken: IWeapon
+        ) {
+            this.katana = katana;
+            this.shuriken = shuriken;
+        }
+    }
+
+    kernel.bind<ISamurai>("ISamurai").to(Samurai4);
+
+    kernel.bind<IWeapon>("IWeapon").to(Katana).when((request: IRequest) => {
+        return request.target.name.equals("katana");
+    });
+
+    kernel.bind<IWeapon>("IWeapon").to(Shuriken).when((request: IRequest) => {
+        return request.target.name.equals("shuriken");
+    });
+
 }
-
-interface BarInterface {
-  name : string;
-  greet() : string;
-}
-
-interface FooBarInterface {
-  foo : FooInterface;
-  bar : BarInterface;
-  greet() : string;
-}
-
-class Foo implements FooInterface {
-  public name : string;
-  constructor() {
-    this.name = "foo";
-  }
-  public greet() : string {
-    return this.name;
-  }
-}
-
-class Bar implements BarInterface {
-  public name : string;
-  constructor() {
-    this.name = "bar";
-  }
-  public greet() : string {
-    return this.name;
-  }
-}
-
-class FooBar implements FooBarInterface {
-  public foo : FooInterface;
-  public bar : BarInterface;
-  constructor(FooInterface : FooInterface, BarInterface : BarInterface) {
-    this.foo = FooInterface;
-    this.bar = BarInterface;
-  }
-  public greet() : string{
-    return this.foo.greet() + this.bar.greet();
-  }
-}
-
-// Kernel
-var kernel = new inversify.Kernel();
-
-// Identifiers
-var fooRuntimeIdentifier = "FooInterface";
-var barRuntimeIdentifier = "BarInterface";
-var fooBarRuntimeIdentifier = "FooBarInterface";
-
-// Bindings
-var fooBinding =  new inversify.TypeBinding<FooInterface>(fooRuntimeIdentifier, Foo);
-var barBinding =  new inversify.TypeBinding<BarInterface>(barRuntimeIdentifier, Bar);
-var fooBarBinding =  new inversify.TypeBinding<FooBarInterface>(fooBarRuntimeIdentifier, FooBar);
-
-kernel.bind(fooBinding);
-kernel.bind(barBinding);
-kernel.bind(fooBarBinding);
-
-// Resolve
-var foo = kernel.resolve<Foo>(fooRuntimeIdentifier);
-var bar = kernel.resolve<Bar>(barRuntimeIdentifier);
-var fooBar = kernel.resolve<FooBar>(fooBarRuntimeIdentifier);
-
-// Unbind
-kernel.unbind(fooRuntimeIdentifier);
-kernel.unbindAll();
diff --git a/inversify/inversify.d.ts b/inversify/inversify.d.ts
index f3c924e82..fe2e3c1f7 100644
--- a/inversify/inversify.d.ts
+++ b/inversify/inversify.d.ts
@@ -1,51 +1,143 @@
-// Type definitions for inversify 1.0.0
+// Type definitions for inversify 2.0.0-alpha.3
 // Project: https://github.com/inversify/InversifyJS
 // Definitions by: inversify <https://github.com/inversify>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-declare module inversify {
-  
-  interface TypeBindingInterface<TServiceType> {
-    runtimeIdentifier : string;
-    implementationType : { new(): TServiceType ;};
-    cache : TServiceType;
-    scope : number; // TypeBindingScopeEnum
-  }
+/// <reference path="../bluebird/bluebird.d.ts" />
 
-  interface KernelInterface {
-    bind(typeBinding : TypeBindingInterface<any>) : void;
-    unbind(runtimeIdentifier : string) : void;
-    unbindAll() : void;
-    resolve<TImplementationType>(runtimeIdentifier : string) : TImplementationType;
-  }
+declare namespace inversify {
 
-  enum TypeBindingScopeEnum {
-      Transient = 0,
-      Singleton = 1,
-  }
+    interface IKernelConstructor {
+        new(options?: IKernelOptions): IKernel;
+    }
 
-  class TypeBinding<TServiceType> implements TypeBindingInterface<TServiceType> {
-      runtimeIdentifier: string;
-      implementationType: {
-          new (): TServiceType;
-      };
-      cache: TServiceType;
-      scope: TypeBindingScopeEnum;
-      constructor(runtimeIdentifier: string, implementationType: {
-          new (...args: any[]): TServiceType;
-      }, scopeType?: TypeBindingScopeEnum);
-  }
+    export interface IKernel {
+        bind<T>(runtimeIdentifier: string): IBindingToSyntax<T>;
+        unbind(runtimeIdentifier: string): void;
+        unbindAll(): void;
+        get<T>(runtimeIdentifier: string): T;
+        getAll<T>(runtimeIdentifier: string): T[];
+    }
 
-  class Kernel implements KernelInterface {
-      private _bindings;
-      bind(typeBinding: TypeBindingInterface<any>): void;
-      unbind(runtimeIdentifier: string): void;
-      unbindAll(): void;
-      resolve<TImplementationType>(runtimeIdentifier: string): TImplementationType;
-      private _validateBinding(typeBinding);
-      private _getConstructorArguments(func);
-      private _injectDependencies<TImplementationType>(func);
-      private _construct<TImplementationType>(constr, args);
-      constructor();
-  }
+    export interface IKernelOptions {
+        middleware?: IMiddleware[];
+        modules?: IKernelModule[];
+    }
+
+    interface IMiddleware extends Function {
+        (...args: any[]): any;
+    }
+
+    export interface IKernelModule extends Function {
+        (kernel: IKernel): void;
+    }
+
+    interface IBindingToSyntax<T> {
+        to(constructor: { new(...args: any[]): T; }): IBindingInWhenProxySyntax<T>;
+        toValue(value: T): IBindingInWhenProxySyntax<T>;
+        toConstructor<T2>(constructor: INewable<T2>): IBindingInWhenProxySyntax<T>;
+        toFactory<T2>(factory: IFactoryCreator<T2>): IBindingInWhenProxySyntax<T>;
+        toAutoFactory<T2>(): IBindingInWhenProxySyntax<T>;
+        toProvider<T2>(provider: IProviderCreator<T2>): IBindingInWhenProxySyntax<T>;
+    }
+
+    interface IBindingInWhenProxySyntax<T> {
+        inTransientScope(): IBindingInWhenProxySyntax<T>;
+        inSingletonScope(): IBindingInWhenProxySyntax<T>;
+        when(constraint: (request: IRequest) => boolean): IBindingInWhenProxySyntax<T>;
+        whenTargetNamed(name: string): IBindingInWhenProxySyntax<T>;
+        whenTargetTagged(tag: string, value: any): IBindingInWhenProxySyntax<T>;
+        proxy(fn: (injectable: T) => T): IBindingInWhenProxySyntax<T>;
+    }
+
+    export interface IFactory<T> extends Function {
+        (): T;
+    }
+
+    interface IFactoryCreator<T> extends Function {
+        (context: IContext): IFactory<T>;
+    }
+
+    export interface INewable<T> {
+        new(...args: any[]): T;
+    }
+
+    export interface IProvider<T> extends Function {
+        (): Promise<T>;
+    }
+
+    interface IProviderCreator<T> extends Function {
+        (context: IContext): IProvider<T>;
+    }
+
+    export interface IContext {
+        kernel: IKernel;
+        plan: IPlan;
+        addPlan(plan: IPlan): void;
+    }
+
+    export interface IPlan {
+        parentContext: IContext;
+        rootRequest: IRequest;
+    }
+
+    export interface IRequest {
+        service: string;
+        parentContext: IContext;
+        parentRequest: IRequest;
+        childRequests: IRequest[];
+        target: ITarget;
+        bindings: IBinding<any>[];
+        addChildRequest(
+            service: string,
+            bindings: (IBinding<any>|IBinding<any>[]),
+            target: ITarget): IRequest;
+    }
+
+    export interface IBinding<T> {
+        runtimeIdentifier: string;
+        implementationType: INewable<T>;
+        factory: IFactoryCreator<any>;
+        provider: IProviderCreator<any>;
+        constraint: (request: IRequest) => boolean;
+        proxyMaker: (injectable: T) => T;
+        cache: T;
+        scope: number; // BindingScope
+        type: number; // BindingType
+    }
+
+    export interface ITarget {
+        service: IQueryableString;
+        name: IQueryableString;
+        metadata: Array<IMetadata>;
+        isArray(): boolean;
+        isNamed(): boolean;
+        isTagged(): boolean;
+        matchesName(name: string): boolean;
+        matchesTag(name: IMetadata): boolean;
+    }
+
+    export interface IQueryableString {
+        startsWith(searchString: string): boolean;
+        endsWith(searchString: string): boolean;
+        contains(searchString: string): boolean;
+        equals(compareString: string): boolean;
+        value(): string;
+    }
+
+    export interface IMetadata {
+        key: string;
+        value: any;
+    }
+
+    export var Kernel: IKernelConstructor;
+    export var decorate: any;
+    export function inject(...typeIdentifiers: string[]): (typeConstructor: any) => void;
+    export var tagged: any;
+    export var named: any;
+    export var paramNames: any;
+}
+
+declare module "inversify" {
+  export = inversify;
 }
diff --git a/jquery-mockjax/jquery-mockjax.d.ts b/jquery-mockjax/jquery-mockjax.d.ts
index df1317552..6cf2d2c06 100644
--- a/jquery-mockjax/jquery-mockjax.d.ts
+++ b/jquery-mockjax/jquery-mockjax.d.ts
@@ -20,6 +20,7 @@ interface MockJaxSettings {
     statusText?: string;
     responseTime?: number;
     isTimeout?: boolean;
+    dataType?: string;
     contentType?: string;
     response?: (settings: any) => void;
     responseText?: string | Object;
diff --git a/jsnox/jsnox-tests.ts b/jsnox/jsnox-tests.ts
index 33e58720e..c1203f089 100644
--- a/jsnox/jsnox-tests.ts
+++ b/jsnox/jsnox-tests.ts
@@ -19,7 +19,7 @@ var clickHandler: React.MouseEventHandler
 
 // Tests with spec string
 function spec_string () {
-    var result: React.ReactHTMLElement
+    var result: React.ReactHTMLElement<HTMLElement>
     
     // just spec string
     result = $('div')
diff --git a/jsnox/jsnox.d.ts b/jsnox/jsnox.d.ts
index 22291956d..68687f719 100644
--- a/jsnox/jsnox.d.ts
+++ b/jsnox/jsnox.d.ts
@@ -31,7 +31,7 @@ declare module 'jsnox' {
          * @param children A single React node (string or ReactElement) or array of nodes.
          * Note that unlike with React itself, multiple children must be placed into an array. 
          */
-        <P>(specString: string, children: React.ReactNode): React.DOMElement<P>
+        <P>(specString: string, children: React.ReactNode): React.DOMElement<P, Element>
 
         /**
          * Renders an HTML element from the given spec string, with optional props 
@@ -42,7 +42,7 @@ declare module 'jsnox' {
          * @param children A single React node (string or ReactElement) or array of nodes.
          * Note that unlike with React itself, multiple children must be placed into an array. 
          */
-        <P>(specString: string, props?: React.HTMLAttributes, children?: React.ReactNode): React.DOMElement<P>
+        <P>(specString: string, props?: React.HTMLAttributes, children?: React.ReactNode): React.DOMElement<P, Element>
 
 
         /**
diff --git a/jss/jss-tests.ts b/jss/jss-tests.ts
new file mode 100644
index 000000000..e5bde70be
--- /dev/null
+++ b/jss/jss-tests.ts
@@ -0,0 +1,16 @@
+/// <reference path="jss.d.ts" />
+
+jss.set('.demo', {
+    'font-size': '15px',
+    'color': 'red'
+});
+
+jss.get('.demo');
+
+jss.get();
+
+jss.getAll('.demo');
+
+jss.remove('.demo');
+
+jss.remove();
diff --git a/jss/jss.d.ts b/jss/jss.d.ts
new file mode 100644
index 000000000..61938cc02
--- /dev/null
+++ b/jss/jss.d.ts
@@ -0,0 +1,50 @@
+// Type definitions for jss v0.6
+// Project: https://github.com/Box9/jss
+// Definitions by: Valentin Robert <https://github.com/Ptival/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface Properties {
+    [name: string]: string;
+}
+
+interface Selectors {
+    [selector: string]: Properties;
+}
+
+interface JSS {
+    /**
+     * Retrieve all rules added via JSS, organized by selectors
+     */
+    get(): Selectors;
+
+    /**
+     * Retrieve rules added via JSS for a given selector
+     * @param s CSS selector
+     */
+    get(s: string): Properties;
+
+    /**
+     * Retrieve all rules specified for a given selector (not necessarily added via JSS)
+     * @param s CSS selector
+     */
+    getAll(s: string): Properties;
+
+    /**
+     * Remove all rules added via JSS
+     */
+    remove(): void;
+
+    /**
+     * Remove all rules added via JSS for the given selector
+     */
+    remove(s: string): void;
+
+    /**
+     * Add or extend an existing rule
+     * @param s CSS selector
+     * @param p CSS properties
+     */
+    set(s: string, p: Properties): void;
+}
+
+declare var jss: JSS;
diff --git a/kendo-ui/kendo-ui.d.ts b/kendo-ui/kendo-ui.d.ts
index f1a72d57c..035b8c6fc 100644
--- a/kendo-ui/kendo-ui.d.ts
+++ b/kendo-ui/kendo-ui.d.ts
@@ -1,4 +1,4 @@
-// Type definitions for Kendo UI Professional v2016.1.226
+// Type definitions for Kendo UI Professional v2016.1.314
 // Project: http://www.telerik.com/kendo-ui
 // Definitions by: Telerik <https://github.com/telerik/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
@@ -246,6 +246,8 @@ declare module kendo {
         };
     };
 
+    var version: string;
+
     interface TemplateOptions {
         paramName?: string;
         useWithBlock?: boolean;
@@ -301,7 +303,7 @@ declare module kendo {
 
     class Layout extends View {
         containers: { [selector: string]: ViewContainer; };
-        showIn(selector: string, view: View): void;
+        showIn(selector: string, view: View, transitionClass?: string): void;
     }
 
     class History extends Observable {
@@ -317,8 +319,13 @@ declare module kendo {
 
     interface RouterOptions {
         init?: (e: RouterEvent) => void;
-        routeMissing?: (e: RouterEvent) => void;
-        change?: (e: RouterEvent) => void;
+        pushState?: boolean;
+        hashBang?: boolean;
+        root?: string;
+        ignoreCase?: boolean;
+        change?(e: RouterChangeEvent): void;
+        routeMissing?(e: RouterRouteMissingEvent): void;
+        same?(e: RouterEvent): void;
     }
 
     interface RouterEvent {
@@ -328,6 +335,15 @@ declare module kendo {
         isDefaultPrevented(): boolean;
     }
 
+    interface RouterChangeEvent extends RouterEvent {
+        params: any;
+        backButtonPressed: boolean;
+    }
+
+    interface RouterRouteMissingEvent extends RouterEvent {
+        params: any;
+    }
+
     class Route extends Class {
         route: RegExp;
         callback(url: string): void;
@@ -348,6 +364,9 @@ declare module kendo {
 }
 
 declare module kendo.effects {
+    function enable(): void;
+    function disable(): void;
+
     interface Element {
         expand(direction: string): effects.Expand;
         expandHorizontal(): effects.Expand;
@@ -932,6 +951,7 @@ declare module kendo.data {
     interface DataSourceSchemaModel {
         id?: string;
         fields?: any;
+        [index: string]: any;
     }
 
     interface DataSourceSchemaModelWithFieldsArray extends DataSourceSchemaModel {
@@ -4390,6 +4410,9 @@ declare module kendo.ui {
         landscape?: boolean;
         margin?: GridPdfMargin;
         paperSize?: string|any;
+        template?: string;
+        repeatHeaders?: boolean;
+        scale?: number|any|any;
         proxyURL?: string;
         proxyTarget?: string;
         subject?: string;
@@ -6555,9 +6578,16 @@ declare module kendo.ui {
         mergedCells?: any;
         rows?: SpreadsheetSheetRow[];
         selection?: string;
+        showGridLines?: boolean;
         sort?: SpreadsheetSheetSort;
     }
 
+    interface SpreadsheetToolbar {
+        home?: boolean|any;
+        insert?: boolean|any;
+        data?: boolean|any;
+    }
+
     interface SpreadsheetInsertSheetOptions {
         rows?: number;
         columns?: number;
@@ -6582,7 +6612,7 @@ declare module kendo.ui {
         rows?: number;
         sheets?: SpreadsheetSheet[];
         sheetsbar?: boolean;
-        toolbar?: boolean;
+        toolbar?: SpreadsheetToolbar;
         change?(e: SpreadsheetChangeEvent): void;
         render?(e: SpreadsheetRenderEvent): void;
         excelExport?(e: SpreadsheetExcelExportEvent): void;
@@ -7854,9 +7884,9 @@ declare module kendo.ui {
 
         center(): kendo.ui.Window;
         close(): kendo.ui.Window;
-        content(): any;
-        content(content?: string): void;
-        content(content?: JQuery): void;
+        content(): string;
+        content(content?: string): kendo.ui.Window;
+        content(content?: JQuery): kendo.ui.Window;
         destroy(): void;
         maximize(): kendo.ui.Window;
         minimize(): kendo.ui.Window;
@@ -7865,8 +7895,8 @@ declare module kendo.ui {
         refresh(options: any): kendo.ui.Window;
         restore(): kendo.ui.Window;
         setOptions(options: any): void;
-        title(): kendo.ui.Window;
-        title(text?: string): void;
+        title(): string;
+        title(text?: string): kendo.ui.Window;
         toFront(): kendo.ui.Window;
         toggleMaximization(): kendo.ui.Window;
         unpin(): void;
@@ -10332,9 +10362,9 @@ declare module kendo.dataviz.ui {
         options: DiagramOptions;
 
         dataSource: kendo.data.DataSource;
-        connections: DiagramConnection[];
+        connections: kendo.dataviz.diagram.Connection[];
         connectionsDataSource: kendo.data.DataSource;
-        shapes: DiagramShape[];
+        shapes: kendo.dataviz.diagram.Shape[];
 
         element: JQuery;
         wrapper: JQuery;
@@ -15753,6 +15783,7 @@ declare module kendo.spreadsheet {
         fontFamily(value?: string): void;
         fontSize(): number;
         fontSize(value?: number): void;
+        forEachCell(callback: Function): void;
         format(): string;
         format(format?: string): void;
         formula(): string;
@@ -15824,6 +15855,8 @@ declare module kendo.spreadsheet {
         rowHeight(): void;
         rowHeight(index: number, width?: number): void;
         selection(): kendo.spreadsheet.Range;
+        showGridLines(): boolean;
+        showGridLines(showGridLiens?: boolean): void;
         toJSON(): void;
         unhideColumn(index: number): void;
         unhideRow(index: number): void;
@@ -16959,6 +16992,7 @@ declare module kendo.ooxml {
         filter?: WorkbookSheetFilter;
         name?: string;
         rows?: WorkbookSheetRow[];
+        showGridLines?: boolean;
         title?: string;
     }
 
diff --git a/lodash/lodash-tests-3.10.ts b/lodash/lodash-3.10-tests.ts
similarity index 98%
rename from lodash/lodash-tests-3.10.ts
rename to lodash/lodash-3.10-tests.ts
index 857432083..9459b5eb9 100644
--- a/lodash/lodash-tests-3.10.ts
+++ b/lodash/lodash-3.10-tests.ts
@@ -6340,28 +6340,28 @@ namespace TestClone {
         let customizer: CloneCustomizer<number, string>;
         let result: string;
 
-        result = _.clone<number>(42, false, customizer);
-        result = _.clone<number>(42, false, customizer, any);
-        result = _.clone<number>(42, customizer);
-        result = _.clone<number>(42, customizer, any);
+        result = _.clone<string>(42, false, customizer);
+        result = _.clone<string>(42, false, customizer, any);
+        result = _.clone<string>(42, customizer);
+        result = _.clone<string>(42, customizer, any);
         result = _.clone<number, string>(42, false, customizer);
         result = _.clone<number, string>(42, false, customizer, any);
         result = _.clone<number, string>(42, customizer);
         result = _.clone<number, string>(42, customizer, any);
-        result = _(42).clone<number>(false, customizer);
-        result = _(42).clone<number>(false, customizer, any);
-        result = _(42).clone<number>(customizer);
-        result = _(42).clone<number>(customizer, any);
+        result = _(42).clone<string>(false, customizer);
+        result = _(42).clone<string>(false, customizer, any);
+        result = _(42).clone<string>(customizer);
+        result = _(42).clone<string>(customizer, any);
     }
 
     {
         let customizer: CloneCustomizer<number, string>;
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _(42).chain().clone<number>(false, customizer);
-        result = _(42).chain().clone<number>(false, customizer, any);
-        result = _(42).chain().clone<number>(customizer);
-        result = _(42).chain().clone<number>(customizer, any);
+        result = _(42).chain().clone<string>(false, customizer);
+        result = _(42).chain().clone<string>(false, customizer, any);
+        result = _(42).chain().clone<string>(customizer);
+        result = _(42).chain().clone<string>(customizer, any);
     }
 
     {
@@ -6386,28 +6386,28 @@ namespace TestClone {
         let customizer: CloneCustomizer<number[], string[]>;
         let result: string[];
 
-        result = _.clone<number[]>([42], false, customizer);
-        result = _.clone<number[]>([42], false, customizer, any);
-        result = _.clone<number[]>([42], customizer);
-        result = _.clone<number[]>([42], customizer, any);
+        result = _.clone<string[]>([42], false, customizer);
+        result = _.clone<string[]>([42], false, customizer, any);
+        result = _.clone<string[]>([42], customizer);
+        result = _.clone<string[]>([42], customizer, any);
         result = _.clone<number[], string[]>([42], false, customizer);
         result = _.clone<number[], string[]>([42], false, customizer, any);
         result = _.clone<number[], string[]>([42], customizer);
         result = _.clone<number[], string[]>([42], customizer, any);
-        result = _([42]).clone<number[]>(false, customizer);
-        result = _([42]).clone<number[]>(false, customizer, any);
-        result = _([42]).clone<number[]>(customizer);
-        result = _([42]).clone<number[]>(customizer, any);
+        result = _([42]).clone<string[]>(false, customizer);
+        result = _([42]).clone<string[]>(false, customizer, any);
+        result = _([42]).clone<string[]>(customizer);
+        result = _([42]).clone<string[]>(customizer, any);
     }
 
     {
         let customizer: CloneCustomizer<number[], string[]>;
         let result: _.LoDashExplicitArrayWrapper<string>;
 
-        result = _([42]).chain().clone<number[]>(false, customizer);
-        result = _([42]).chain().clone<number[]>(false, customizer, any);
-        result = _([42]).chain().clone<number[]>(customizer);
-        result = _([42]).chain().clone<number[]>(customizer, any);
+        result = _([42]).chain().clone<string>(false, customizer);
+        result = _([42]).chain().clone<string>(false, customizer, any);
+        result = _([42]).chain().clone<string>(customizer);
+        result = _([42]).chain().clone<string>(customizer, any);
     }
 
     {
@@ -6432,28 +6432,28 @@ namespace TestClone {
         let customizer: CloneCustomizer<{a: {b: number;};}, {a: {b: string;};}>;
         let result: {a: {b: string;};};
 
-        result = _.clone<{a: {b: number;};}>({a: {b: 42}}, false, customizer);
-        result = _.clone<{a: {b: number;};}>({a: {b: 42}}, false, customizer, any);
-        result = _.clone<{a: {b: number;};}>({a: {b: 42}}, customizer);
-        result = _.clone<{a: {b: number;};}>({a: {b: 42}}, customizer, any);
+        result = _.clone<{a: {b: string;};}>({a: {b: 42}}, false, customizer);
+        result = _.clone<{a: {b: string;};}>({a: {b: 42}}, false, customizer, any);
+        result = _.clone<{a: {b: string;};}>({a: {b: 42}}, customizer);
+        result = _.clone<{a: {b: string;};}>({a: {b: 42}}, customizer, any);
         result = _.clone<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, false, customizer);
         result = _.clone<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, false, customizer, any);
         result = _.clone<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, customizer);
         result = _.clone<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, customizer, any);
-        result = _({a: {b: 42}}).clone<{a: {b: number;};}>(false, customizer);
-        result = _({a: {b: 42}}).clone<{a: {b: number;};}>(false, customizer, any);
-        result = _({a: {b: 42}}).clone<{a: {b: number;};}>(customizer);
-        result = _({a: {b: 42}}).clone<{a: {b: number;};}>(customizer, any);
+        result = _({a: {b: 42}}).clone<{a: {b: string;};}>(false, customizer);
+        result = _({a: {b: 42}}).clone<{a: {b: string;};}>(false, customizer, any);
+        result = _({a: {b: 42}}).clone<{a: {b: string;};}>(customizer);
+        result = _({a: {b: 42}}).clone<{a: {b: string;};}>(customizer, any);
     }
 
     {
         let customizer: CloneCustomizer<{a: {b: number;};}, {a: {b: string;};}>;
         let result: _.LoDashExplicitObjectWrapper<{a: {b: string;};}>;
 
-        result = _({a: {b: 42}}).chain().clone<{a: {b: number;};}>(false, customizer);
-        result = _({a: {b: 42}}).chain().clone<{a: {b: number;};}>(false, customizer, any);
-        result = _({a: {b: 42}}).chain().clone<{a: {b: number;};}>(customizer);
-        result = _({a: {b: 42}}).chain().clone<{a: {b: number;};}>(customizer, any);
+        result = _({a: {b: 42}}).chain().clone<{a: {b: string;};}>(false, customizer);
+        result = _({a: {b: 42}}).chain().clone<{a: {b: string;};}>(false, customizer, any);
+        result = _({a: {b: 42}}).chain().clone<{a: {b: string;};}>(customizer);
+        result = _({a: {b: 42}}).chain().clone<{a: {b: string;};}>(customizer, any);
     }
 }
 
@@ -6475,27 +6475,27 @@ namespace TestCloneDeep {
         let customizer: CloneDeepCustomizer<number, number>;
         let result: _.LoDashExplicitWrapper<number>;
 
-        result = _(42).chain.cloneDeep();
+        result = _(42).chain().cloneDeep();
     }
 
     {
         let customizer: CloneDeepCustomizer<number, string>;
         let result: string;
 
-        result = _.cloneDeep<number>(42, customizer);
-        result = _.cloneDeep<number>(42, customizer, any);
+        result = _.cloneDeep<string>(42, customizer);
+        result = _.cloneDeep<string>(42, customizer, any);
         result = _.cloneDeep<number, string>(42, customizer);
         result = _.cloneDeep<number, string>(42, customizer, any);
-        result = _(42).cloneDeep<number>(customizer);
-        result = _(42).cloneDeep<number>(customizer, any);
+        result = _(42).cloneDeep<string>(customizer);
+        result = _(42).cloneDeep<string>(customizer, any);
     }
 
     {
         let customizer: CloneDeepCustomizer<number, string>;
         let result: _.LoDashExplicitWrapper<string>;
 
-        result = _(42).chain().cloneDeep<number>(customizer);
-        result = _(42).chain().cloneDeep<number>(customizer, any);
+        result = _(42).chain().cloneDeep<string>(customizer);
+        result = _(42).chain().cloneDeep<string>(customizer, any);
     }
 
     {
@@ -6517,20 +6517,20 @@ namespace TestCloneDeep {
         let customizer: CloneDeepCustomizer<number[], string[]>;
         let result: string[];
 
-        result = _.cloneDeep<number[]>([42], customizer);
-        result = _.cloneDeep<number[]>([42], customizer, any);
+        result = _.cloneDeep<string[]>([42], customizer);
+        result = _.cloneDeep<string[]>([42], customizer, any);
         result = _.cloneDeep<number[], string[]>([42], customizer);
         result = _.cloneDeep<number[], string[]>([42], customizer, any);
-        result = _([42]).cloneDeep<number[]>(customizer);
-        result = _([42]).cloneDeep<number[]>(customizer, any);
+        result = _([42]).cloneDeep<string[]>(customizer);
+        result = _([42]).cloneDeep<string[]>(customizer, any);
     }
 
     {
         let customizer: CloneDeepCustomizer<number[], string[]>;
         let result: _.LoDashExplicitArrayWrapper<string>;
 
-        result = _([42]).chain().cloneDeep<number[]>(customizer);
-        result = _([42]).chain().cloneDeep<number[]>(customizer, any);
+        result = _([42]).chain().cloneDeep<string>(customizer);
+        result = _([42]).chain().cloneDeep<string>(customizer, any);
     }
 
     {
@@ -6552,20 +6552,20 @@ namespace TestCloneDeep {
         let customizer: CloneDeepCustomizer<{a: {b: number;};}, {a: {b: string;};}>;
         let result: {a: {b: string;};};
 
-        result = _.cloneDeep<{a: {b: number;};}>({a: {b: 42}}, customizer);
-        result = _.cloneDeep<{a: {b: number;};}>({a: {b: 42}}, customizer, any);
+        result = _.cloneDeep<{a: {b: string;};}>({a: {b: 42}}, customizer);
+        result = _.cloneDeep<{a: {b: string;};}>({a: {b: 42}}, customizer, any);
         result = _.cloneDeep<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, customizer);
         result = _.cloneDeep<{a: {b: number;};}, {a: {b: string;};}>({a: {b: 42}}, customizer, any);
-        result = _({a: {b: 42}}).cloneDeep<{a: {b: number;};}>(customizer);
-        result = _({a: {b: 42}}).cloneDeep<{a: {b: number;};}>(customizer, any);
+        result = _({a: {b: 42}}).cloneDeep<{a: {b: string;};}>(customizer);
+        result = _({a: {b: 42}}).cloneDeep<{a: {b: string;};}>(customizer, any);
     }
 
     {
         let customizer: CloneDeepCustomizer<{a: {b: number;};}, {a: {b: string;};}>;
         let result: _.LoDashExplicitObjectWrapper<{a: {b: string;};}>;
 
-        result = _({a: {b: 42}}).chain().cloneDeep<{a: {b: number;};}>(customizer);
-        result = _({a: {b: 42}}).chain().cloneDeep<{a: {b: number;};}>(customizer, any);
+        result = _({a: {b: 42}}).chain().cloneDeep<{a: {b: string;};}>(customizer);
+        result = _({a: {b: 42}}).chain().cloneDeep<{a: {b: string;};}>(customizer, any);
     }
 }
 
diff --git a/lodash/lodash-3.10.d.ts b/lodash/lodash-3.10.d.ts
index 0f6e5a6e4..f5cfe0754 100644
--- a/lodash/lodash-3.10.d.ts
+++ b/lodash/lodash-3.10.d.ts
@@ -10240,7 +10240,7 @@ declare module _ {
          */
         clone(
             isDeep?: boolean
-        ): T;
+        ): T[];
     }
 
     interface LoDashImplicitObjectWrapper<T> {
@@ -10519,7 +10519,7 @@ declare module _ {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(): T;
+        cloneDeep(): T[];
     }
 
     interface LoDashImplicitObjectWrapper<T> {
@@ -10565,9 +10565,7 @@ declare module _ {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            isDeep?: boolean
-        ): LoDashExplicitWrapper<T>;
+        cloneDeep(): LoDashExplicitWrapper<T>;
     }
 
     interface LoDashExplicitArrayWrapper<T> {
@@ -10598,9 +10596,7 @@ declare module _ {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            isDeep?: boolean
-        ): LoDashExplicitArrayWrapper<T>;
+        cloneDeep(): LoDashExplicitArrayWrapper<T>;
     }
 
     interface LoDashExplicitObjectWrapper<T> {
@@ -10631,9 +10627,7 @@ declare module _ {
         /**
          * @see _.cloneDeep
          */
-        cloneDeep(
-            isDeep?: boolean
-        ): LoDashExplicitObjectWrapper<T>;
+        cloneDeep(): LoDashExplicitObjectWrapper<T>;
     }
 
     //_.eq
diff --git a/lodash/lodash-tests.ts b/lodash/lodash-tests.ts
index daf6ab099..afbad410d 100644
--- a/lodash/lodash-tests.ts
+++ b/lodash/lodash-tests.ts
@@ -7170,6 +7170,37 @@ module TestIsUndefined {
     }
 }
 
+// _.isWeakMap
+module TestIsWeakMap {
+    {
+        let value: number|WeakMap<string, number>;
+
+        if (_.isWeakMap<string, number>(value)) {
+            let result: WeakMap<string, number> = value;
+        }
+        else {
+            let result: number = value;
+        }
+    }
+
+    {
+        let result: boolean;
+
+        result = _.isWeakMap(any);
+        result = _(1).isWeakMap();
+        result = _<any>([]).isWeakMap();
+        result = _({}).isWeakMap();
+    }
+
+    {
+        let result: _.LoDashExplicitWrapper<boolean>;
+
+        result = _(1).chain().isWeakMap();
+        result = _<any>([]).chain().isWeakMap();
+        result = _({}).chain().isWeakMap();
+    }
+}
+
 // _.lt
 module TestLt {
     {
diff --git a/lodash/lodash.d.ts b/lodash/lodash.d.ts
index 5285b0e6f..02a32583a 100644
--- a/lodash/lodash.d.ts
+++ b/lodash/lodash.d.ts
@@ -12267,6 +12267,31 @@ declare module _ {
         isUndefined(): LoDashExplicitWrapper<boolean>;
     }
 
+    //_.isWeakMap
+    interface LoDashStatic {
+        /**
+         * Checks if value is classified as a WeakMap object.
+         *
+         * @param value The value to check.
+         * @returns Returns true if value is correctly classified, else false.
+         */
+        isWeakMap<K, V>(value?: any): value is WeakMap<K, V>;
+    }
+
+    interface LoDashImplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isSet
+         */
+        isWeakMap(): boolean;
+    }
+
+    interface LoDashExplicitWrapperBase<T, TWrapper> {
+        /**
+         * @see _.isSet
+         */
+        isWeakMap(): LoDashExplicitWrapper<boolean>;
+    }
+
     //_.lt
     interface LoDashStatic {
         /**
@@ -18487,3 +18512,4 @@ declare module "lodash" {
 // Backward compatibility with --target es5
 interface Set<T> {}
 interface Map<K, V> {}
+interface WeakMap<K, V> {}
diff --git a/lokijs/lokijs.d.ts b/lokijs/lokijs.d.ts
index 1e93bb370..25d2e3cb6 100644
--- a/lokijs/lokijs.d.ts
+++ b/lokijs/lokijs.d.ts
@@ -3,7 +3,7 @@
 // Definitions by: TeamworkGuy2 <https://github.com/TeamworkGuy2>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
-// NOTE: definition last updated (2015-6-6) based on latest code as of https://github.com/techfort/LokiJS/commit/4ffdda188c59ac06b760575b4ca41ad591ca8b0d
+// NOTE: definition last updated (2016-3-13) based on latest code as of https://github.com/techfort/LokiJS/commit/3d2cf9546cd22556444deeabc4df314f227ecf5c
 
 /** LokiJS
  * A lightweight document oriented javascript database
@@ -17,45 +17,50 @@
  * @param {object} options - config object
  */
 interface Loki extends LokiEventEmitter {
-    filename: string;
+    // autosave support (disabled by default)
+    autosave: boolean;
+    autosaveInterval: number; // milliseconds between auto-saves
+    autosaveHandle: number; // ID from setInterval(...)
     collections: LokiCollection<any>[];
     databaseVersion: number;
     engineVersion: number;
-    // autosave support (disabled by default)
-    // pass autosave: true, autosaveInterval: 6000 in options to set 6 second autosave
-    autosave: boolean;
-    autosaveInterval: number;
-    autosaveHandle: number; // from setInterval() call
+    ENV: string;/*NODEJS, CORDOVA, BROWSER*/
+    events: { [id: string]: ((...args: any[]) => void)[] }; /*{
+        'init': ((...args) => void)[];
+        'loaded': ((...args) => void)[];
+        'flushChanges': ((...args) => void)[];
+        'close': ((...args) => void)[];
+        'changes': ((...args) => void)[];
+        'warning': ((...args) => void)[];
+    };*/
+    filename: string;
     options: LokiConfigureOptions;
-    // currently keeping persistenceMethod and persistenceAdapter as loki level properties that
-    // will not or cannot be deserialized.  You are required to configure persistence every time
-    // you instantiate a loki object (or use default environment detection) in order to load the database anyways.
+    persistenceAdapter: LokiPersistenceInterface;
     // persistenceMethod could be 'fs', 'localStorage', or 'adapter'
     // this is optional option param, otherwise environment detection will be used
     // if user passes their own adapter we will force this method to 'adapter' later, so no need to pass method option.
-    persistenceMethod: string;
-    // retain reference to optional (non-serializable) persistenceAdapter 'instance'
-    persistenceAdapter: LokiPersistenceInterface;
-    ENV: string;
-    events: {
-        'init': any[];
-        'flushChanges': any[];
-        'close': any[];
-        'changes': any[];
-        'warning': any[];
-    };
+    persistenceMethod: string; /*'fs', 'localStorage', 'adapter'*/
+    verbose: boolean;
 
     new (filename: string, options: LokiConfigureOptions): Loki;
 
+    // experimental support for browserify's abstract syntax scan to pick up dependency of indexed adapter.
+    // Hopefully, once this hits npm a browserify require of lokijs should scan the main file and detect this indexed adapter reference.
+    getIndexedAdapter(): LokiPersistenceInterface; // require("./loki-indexed-adapter.js")
+
+
     /** configureOptions - allows reconfiguring database options
+     *
      * @param {object} options - configuration options to apply to loki db object
      * @param {boolean} initialConfig - (optional) if this is a reconfig, don't pass this
      */
     configureOptions(options: LokiConfigureOptions, initialConfig?: boolean): void;
 
     /** anonym() - shorthand method for quickly creating and populating an anonymous collection.
-     *     This collection is not referenced internally so upon losing scope it will be garbage collected.
-     *   Example : var results = new loki().anonym(myDocArray).find({'age': {'$gt': 30} });
+     *    This collection is not referenced internally so upon losing scope it will be garbage collected.
+     *
+     *    Example : var results = new loki().anonym(myDocArray).find({'age': {'$gt': 30} });
+     *
      * @param {Array} docs - document array to initialize the anonymous collection with
      * @param {Array} indexesArray - (Optional) array of property names to index
      * @returns {Collection} New collection which you can query or chain
@@ -74,7 +79,8 @@ interface Loki extends LokiEventEmitter {
 
     getName(): string;
 
-    /** serializeReplacer - used to prevent certain properties from being serialized, may return null */
+    /** serializeReplacer - used to prevent certain properties from being serialized
+     */
     serializeReplacer<T>(key: "autosaveHandle", value: T): T;
     serializeReplacer<T>(key: "persistenceAdapter", value: T): T;
     serializeReplacer<T>(key: "constraints", value: T): T;
@@ -87,17 +93,24 @@ interface Loki extends LokiEventEmitter {
     toJson(): string;
 
     /** loadJSON - inflates a loki database from a serialized JSON string
+     *
      * @param {string} serializedDb - a serialized loki database string
      * @param {object} options - apply or override collection level settings
      */
-    loadJSON(serializedDb: string, options: { [id: string]: { inflate?: (a: any, b: any) => void; proto: any; } }): void;
+    loadJSON(serializedDb: string, options?: { [collectionName: string]: { inflate?: (src: any, dst: any) => void; proto: any; } }): void;
+
+    /** loadJSONObject - inflates a loki database from a JS object
+     *
+     * @param {object} dbObject - a serialized loki database string
+     * @param {object} options - apply or override collection level settings
+     */
+    loadJSONObject(dbObject: Loki, options?: { [collectionName: string]: { inflate?: (src: any, dst: any) => void; proto: any; } }): void;
 
     /** close(callback) - emits the close event with an optional callback. Does not actually destroy the db
      * but useful from an API perspective
      */
     close(callback?: (...args: any[]) => void): void;
 
-
     /**-------------------------+
     | Changes API               |
     +--------------------------*/
@@ -107,8 +120,9 @@ interface Loki extends LokiEventEmitter {
      */
 
     /** generateChangesNotification() - takes all the changes stored in each
-     *   collection and creates a single array for the entire database. If an array of names
-     *   of collections is passed then only the included collections will be tracked.
+     * collection and creates a single array for the entire database. If an array of names
+     * of collections is passed then only the included collections will be tracked.
+     *
      * @param {array} optional array of collection names. No arg means all collections are processed.
      * @returns {array} array of changes
      * @see private method createChange() in Collection
@@ -120,27 +134,40 @@ interface Loki extends LokiEventEmitter {
      */
     serializeChanges(collectionNamesArray?: string[]): string;
 
-    /** clearChanges() - clears all the changes in all collections. */
+    /** clearChanges() - clears all the changes in all collections.
+     */
     clearChanges(): void;
 
     /** loadDatabase - Handles loading from file system, local storage, or adapter (indexeddb)
-     *   This method utilizes loki configuration options (if provided) to determine which
-     *   persistence method to use, or environment detection (if configuration was not provided).
+     *    This method utilizes loki configuration options (if provided) to determine which
+     *    persistence method to use, or environment detection (if configuration was not provided).
+     *
      * @param {object} options - not currently used (remove or allow overrides?)
      * @param {function} callback - (Optional) user supplied async callback / error handler
      */
-    loadDatabase(options: { [id: string]: { inflate?: (a: any, b: any) => void; proto: any; } }, callback: (err: Error | string, data: any) => void): void;
+    loadDatabase(options: { [collectionName: string]: { inflate?: (src: any, dst: any) => void; proto: any; } }, callback?: (err: any, data: any) => void): void;
 
     /** saveDatabase - Handles saving to file system, local storage, or adapter (indexeddb)
-     *   This method utilizes loki configuration options (if provided) to determine which
-     *   persistence method to use, or environment detection (if configuration was not provided).
+     *    This method utilizes loki configuration options (if provided) to determine which
+     *    persistence method to use, or environment detection (if configuration was not provided).
+     *
      * @param {object} options - not currently used (remove or allow overrides?)
      * @param {function} callback - (Optional) user supplied async callback / error handler
      */
-    saveDatabase(callback: (err: Error) => void): void;
+    saveDatabase(callback?: (err: any) => void): void;
 
-    // alias
-    save(callback: (err: Error) => void): void;
+    // alias for saveDatabase
+    save(callback ?: (err: any) => void): void;
+
+    /** deleteDatabase - Handles deleting a database from file system, local
+     *    storage, or adapter (indexeddb)
+     *    This method utilizes loki configuration options (if provided) to determine which
+     *    persistence method to use, or environment detection (if configuration was not provided).
+     *
+     * @param {object} options - not currently used (remove or allow overrides?)
+     * @param {function} callback - user supplied async callback / error handler
+     */
+    deleteDatabase(options: any, callback: (err: any, data: any) => void): void;
 
     /** autosaveDirty - check whether any collections are 'dirty' meaning we need to save (entire) database
      * @returns {boolean} - true if database has changed since last autosave, false if not.
@@ -148,49 +175,63 @@ interface Loki extends LokiEventEmitter {
     autosaveDirty(): boolean;
 
     /** autosaveClearFlags - resets dirty flags on all collections.
-     *   Called from saveDatabase() after db is saved.
+     *    Called from saveDatabase() after db is saved.
      */
     autosaveClearFlags(): void;
 
-    /** autosaveEnable - begin a javascript interval to periodically save the database. */
-    autosaveEnable(): void;
+    /** autosaveEnable - begin a javascript interval to periodically save the database.
+     *
+     * @param {object} options - not currently used (remove or allow overrides?)
+     * @param {function} callback - (Optional) user supplied async callback
+     */
+    autosaveEnable(options?: LokiConfigureOptions, callback?: (err: any) => void): void;
 
-    /** autosaveDisable - stop the autosave interval timer. */
+    /** autosaveDisable - stop the autosave interval timer.
+     */
     autosaveDisable(): void;
-
 }
 
 
-/** LokiEventEmitter is a minimalist version of EventEmitter. It enables any
+
+
+/**
+ * LokiEventEmitter is a minimalist version of EventEmitter. It enables any
  * constructor that inherits EventEmitter to emit events and trigger
  * listeners that have been added to the event through the on(event, callback) method
  */
 interface LokiEventEmitter {
-    /** @prop Events property is a hashmap, with each property being an array of callbacks */
-    events: {} //{ [id: string]: ((...args) => void)[] };
+    /**
+     * @prop Events property is a hashmap, with each property being an array of callbacks
+     */
+    events: { [eventName: string]: ((...args: any[]) => void)[] };
 
     new (): LokiEventEmitter;
 
-    /** @prop asyncListeners - boolean determines whether or not the callbacks associated with each event
+    /**
+     * @prop asyncListeners - boolean determines whether or not the callbacks associated with each event
      * should happen in an async fashion or not
      * Default is false, which means events are synchronous
      */
     asyncListeners: boolean;
 
-    /** @prop on(eventName, listener) - adds a listener to the queue of callbacks associated to an event
+    /**
+     * @prop on(eventName, listener) - adds a listener to the queue of callbacks associated to an event
      * @returns {int} the index of the callback in the array of listeners for a particular event
      */
-    on(eventName: string, listener: (...args: any[]) => void): (...args: any[]) => void;
+    on<U extends (...args: any[]) => void>(eventName: string, listener: U): U;
 
-    /** @propt emit(eventName, data) - emits a particular event
+    /**
+     * @propt emit(eventName, data) - emits a particular event
      * with the option of passing optional parameters which are going to be processed by the callback
      * provided signatures match (i.e. if passing emit(event, arg0, arg1) the listener should take two parameters)
      * @param {string} eventName - the name of the event
      * @param {object} data - optional object passed with the event
      */
-    emit(eventName: string, data: any): void;
+    emit(eventName: string, data?: any): void;
 
-    /** @prop remove() - removes the listener at position 'index' from the event 'eventName' */
+    /**
+     * @prop remove() - removes the listener at position 'index' from the event 'eventName'
+     */
     removeListener(eventName: string, listener: (...args: any[]) => void): void;
 }
 
@@ -206,135 +247,184 @@ interface LokiEventEmitter {
  * localStorage   for use in browser environment
  * defined as helper classes here so its easy and clean to use
  */
-interface LokiFsAdapter {
-    //fs; // require('fs');
+
+interface LokiPersistenceInterface {
+    loadDatabase(dbname: string, callback: (dataOrErr: string | Error) => void): void;
+    saveDatabase(dbname: string, dbstring: string, callback: (resOrErr: void | Error) => void): void;
+    deleteDatabase(dbname: string, callback?: (resOrErr: void | Error) => void): void;
+    // optional
+    mode?: string; // 'reference'
+    // filename may seem redundant but loadDatabase will need to expect this same filename
+    exportDatabase?(filename: string, param: any, callback?: (err: any) => void): void;
+}
+
+
+/** constructor for fs
+ */
+interface LokiFsAdapter extends LokiPersistenceInterface {
+    fs: any; //require('fs');
 
     /** loadDatabase() - Load data from file, will throw an error if the file does not exist
      * @param {string} dbname - the filename of the database to load
      * @param {function} callback - the callback to handle the result
      */
-    loadDatabase(dbname: string, callback: (data: string | Error) => void): void;
+    loadDatabase(dbname: string, callback: (err: Error, data: string) => void): void;
 
     /** saveDatabase() - save data to file, will throw an error if the file can't be saved
      * might want to expand this to avoid dataloss on partial save
      * @param {string} dbname - the filename of the database to load
      * @param {function} callback - the callback to handle the result
      */
-    saveDatabase(dbname: string, dbstring: string, callback: (error: any) => void): void;
+    saveDatabase(dbname: string, dbstring: string, callback: (err: any) => void): void;
+
+    /** deleteDatabase() - delete the database file, will throw an error if the
+     * file can't be deleted
+     * @param {string} dbname - the filename of the database to delete
+     * @param {function} callback - the callback to handle the result
+     */
+    deleteDatabase(dbname: string, callback: (resOrErr: void | Error) => void): void;
 }
 
 
-
-
-/** constructor for local storage */
-interface LokiLocalStorageAdapter {
+/** constructor for local storage
+ */
+interface LokiLocalStorageAdapter extends LokiPersistenceInterface {
 
     /** loadDatabase() - Load data from localstorage
      * @param {string} dbname - the name of the database to load
      * @param {function} callback - the callback to handle the result
      */
-    loadDatabase(dbname: string, callback: (data: string | Error) => void): void;
+    loadDatabase(dbname: string, callback: (dataOrErr: string | Error) => void): void;
 
     /** saveDatabase() - save data to localstorage, will throw an error if the file can't be saved
      * might want to expand this to avoid dataloss on partial save
      * @param {string} dbname - the filename of the database to load
      * @param {function} callback - the callback to handle the result
      */
-    saveDatabase(dbname: string, dbstring: string, callback: (error: Error) => void): void;
+    saveDatabase(dbname: string, dbstring: string, callback: (resOrErr: void | Error) => void): void;
+
+    /** deleteDatabase() - delete the database from localstorage, will throw an error if it
+     * can't be deleted
+     * @param {string} dbname - the filename of the database to delete
+     * @param {function} callback - the callback to handle the result
+     */
+    deleteDatabase(dbname: string, callback: (resOrErr: void | Error) => void): void;
 }
 
 
 
 
 /** Resultset class allowing chainable queries.  Intended to be instanced internally.
- *     Collection.find(), Collection.where(), and Collection.chain() instantiate this.
- *   Example:
- *     mycollection.chain()
- *       .find({ 'doors' : 4 })
- *       .where(function(obj) { return obj.name === 'Toyota' })
- *       .data();
- * @param {Collection} collection - The collection which this Resultset will query against.
- * @param {string} queryObj - Optional mongo-style query object to initialize resultset with.
- * @param {function} queryFunc - Optional javascript filter function to initialize resultset with.
- * @param {bool} firstOnly - Optional boolean used by collection.findOne().
+ *    Collection.find(), Collection.where(), and Collection.chain() instantiate this.
+ *
+ *    Example:
+ *    mycollection.chain()
+ *      .find({ 'doors' : 4 })
+ *      .where(function(obj) { return obj.name === 'Toyota' })
+ *      .data();
  */
 interface LokiResultset<E> {
+    // retain reference to collection we are querying against
     collection: LokiCollection<E>;
-    searchIsChained: boolean;
-    filteredrows: string[]; // technically number[] (e.g. = Object.keys(this.collection.data))
     filterInitialized: boolean;
+    filteredrows: string[]; // technically number[] (e.g. = Object.keys(this.collection.data))
+    options: LokiResultsetOptions<E>;
+    searchIsChained: boolean;
 
-    new (collection: LokiCollection<E>, queryObj: LokiQuery, queryFunc: (obj: E) => boolean, firstOnly?: boolean): LokiResultset<E>;
 
-    /** toJSON() - Override of toJSON to avoid circular references */
+    /**
+     * @constructor
+     * @param {Collection} collection - The collection which this Resultset will query against.
+     * @param {Object} options - Object containing one or more options.
+     * @param {string} options.queryObj - Optional mongo-style query object to initialize resultset with.
+     * @param {function} options.queryFunc - Optional javascript filter function to initialize resultset with.
+     * @param {bool} options.firstOnly - Optional boolean used by collection.findOne().
+     */
+    new <E>(collection: LokiCollection<E>, options: LokiResultsetOptions<E>): LokiResultset<E> | E[];
+
+    /** reset() - Reset the resultset to its initial state.
+     *
+     * @returns {Resultset} Reference to this resultset, for future chain operations.
+     */
+    reset(): LokiResultset<E>;
+
+    /** toJSON() - Override of toJSON to avoid circular references
+     */
     toJSON(): LokiResultset<E>;
 
     /** limit() - Allows you to limit the number of documents passed to next chain operation.
-     *   A resultset copy() is made to avoid altering original resultset.
+     *    A resultset copy() is made to avoid altering original resultset.
+     *
      * @param {int} qty - The number of documents to return.
      * @returns {Resultset} Returns a copy of the resultset, limited by qty, for subsequent chain ops.
      */
     limit(qty: number): LokiResultset<E>;
 
     /** offset() - Used for skipping 'pos' number of documents in the resultset.
+     *
      * @param {int} pos - Number of documents to skip; all preceding documents are filtered out.
      * @returns {Resultset} Returns a copy of the resultset, containing docs starting at 'pos' for subsequent chain ops.
      */
     offset(pos: number): LokiResultset<E>;
 
     /** copy() - To support reuse of resultset in branched query situations.
+     *
      * @returns {Resultset} Returns a copy of the resultset (set) but the underlying document references will be the same.
      */
     copy(): LokiResultset<E>;
-
-    // add branch() as alias of copy()
+    // alias of copy()
     branch(): LokiResultset<E>;
 
+    /**
+     * transform() - executes a named collection transform or raw array of transform steps against the resultset.
+     *
+     * @param transform {string|array} : (Optional) name of collection transform or raw transform array
+     * @param parameters {object} : (Optional) object property hash of parameters, if the transform requires them.
+     * @returns {Resultset} : either (this) resultset or a clone of of this resultset (depending on steps)
+     */
+    transform(transform?: string | any[], parameters?: any): LokiResultset<E>;
+
     /** sort() - User supplied compare function is provided two documents to compare. (chainable)
-     *   Example:
-     *     rslt.sort(function(obj1, obj2) {
-     *       if (obj1.name === obj2.name) return 0;
-     *       if (obj1.name > obj2.name) return 1;
-     *       if (obj1.name < obj2.name) return -1;
-     *     });
+     *    Example:
+     *    rslt.sort(function(obj1, obj2) {
+     *      if (obj1.name === obj2.name) return 0;
+     *      if (obj1.name > obj2.name) return 1;
+     *      if (obj1.name < obj2.name) return -1;
+     *    });
+     *
      * @param {function} comparefun - A javascript compare function used for sorting.
      * @returns {Resultset} Reference to this resultset, sorted, for future chain operations.
      */
     sort(comparefun: (a: E, b: E) => number): LokiResultset<E>;
 
     /** simplesort() - Simpler, loose evaluation for user to sort based on a property name. (chainable)
+     *
      * @param {string} propname - name of property to sort by.
      * @param {bool} isdesc - (Optional) If true, the property will be sorted in descending order
      * @returns {Resultset} Reference to this resultset, sorted, for future chain operations.
      */
     simplesort(propname: string, isdesc?: boolean): LokiResultset<E>;
 
-    /** compoundeval() - helper method for compoundsort(), performing individual object comparisons
-     * @param {array} properties - array of property names, in order, by which to evaluate sort order
-     * @param {object} obj1 - first object to compare
-     * @param {object} obj2 - second object to compare
-     * @returns {integer} 0, -1, or 1 to designate if identical (sortwise) or which should be first
-     */
-    compoundeval(properties: any[], obj1: any, obj2: any): number;
-
     /** compoundsort() - Allows sorting a resultset based on multiple columns.
-     *   Example : rs.compoundsort(['age', 'name']); to sort by age and then name (both ascending)
-     *   Example : rs.compoundsort(['age', ['name', true]); to sort by age (ascending) and then by name (descending)
+     *    Example : rs.compoundsort(['age', 'name']); to sort by age and then name (both ascending)
+     *    Example : rs.compoundsort(['age', ['name', true]); to sort by age (ascending) and then by name (descending)
+     *
      * @param {array} properties - array of property names or subarray of [propertyname, isdesc] used evaluate sort order
      * @returns {Resultset} Reference to this resultset, sorted, for future chain operations.
      */
-    compoundsort(properties: any[]): LokiResultset<E>;
+    compoundsort(properties: ([string, boolean] | [string])[]): LokiResultset<E>;
 
     /** calculateRange() - Binary Search utility method to find range/segment of values matching criteria.
-    *   this is used for collection.find() and first find filter of resultset/dynview
-    *   slightly different than get() binary search in that get() hones in on 1 value,
-    *   but we have to hone in on many (range)
-    * @param {string} op - operation, such as $eq
-    * @param {string} prop - name of property to calculate range for
-    * @param {object} val - value to use for range calculation.
-    * @returns {array} [start, end] index array positions
-    */
+     *    this is used for collection.find() and first find filter of resultset/dynview
+     *    slightly different than get() binary search in that get() hones in on 1 value,
+     *    but we have to hone in on many (range)
+     * @param {string} op - operation, such as $eq
+     * @param {string} prop - name of property to calculate range for
+     * @param {object} val - value to use for range calculation.
+     * @returns {array} [start, end] index array positions
+     */
     calculateRange(op: "$eq", prop: string, val: any): [number/*start*/, number/*end*/];
+    calculateRange(op: "$dteq", prop: string, val: any): [number/*start*/, number/*end*/];
     calculateRange(op: "$gt", prop: string, val: any): [number/*start*/, number/*end*/];
     calculateRange(op: "$gte", prop: string, val: any): [number/*start*/, number/*end*/];
     calculateRange(op: "$lt", prop: string, val: any): [number/*start*/, number/*end*/];
@@ -342,57 +432,78 @@ interface LokiResultset<E> {
     calculateRange(op: string, prop: string, val: any): [number/*start*/, number/*end*/];
 
     /** findOr() - oversee the operation of OR'ed query expressions.
-     *   OR'ed expression evaluation runs each expression individually against the full collection,
-     *   and finally does a set OR on each expression's results.
-     *   Each evaluation can utilize a binary index to prevent multiple linear array scans.
+     *    OR'ed expression evaluation runs each expression individually against the full collection,
+     *    and finally does a set OR on each expression's results.
+     *    Each evaluation can utilize a binary index to prevent multiple linear array scans.
+     *
      * @param {array} expressionArray - array of expressions
      * @returns {Resultset} this resultset for further chain ops.
      */
     findOr(expressionArray: LokiQuery[]): LokiResultset<E>;
+    $or(expressionArray: LokiQuery[]): LokiResultset<E>;
 
     /** findAnd() - oversee the operation of AND'ed query expressions.
-     *   AND'ed expression evaluation runs each expression progressively against the full collection,
-     *   internally utilizing existing chained resultset functionality.
-     *   Only the first filter can utilize a binary index.
+     *    AND'ed expression evaluation runs each expression progressively against the full collection,
+     *    internally utilizing existing chained resultset functionality.
+     *    Only the first filter can utilize a binary index.
+     *
      * @param {array} expressionArray - array of expressions
      * @returns {Resultset} this resultset for further chain ops.
      */
     findAnd(expressionArray: LokiQuery[]): LokiResultset<E>;
-
-    /** dotSubScan - helper function used for dot notation queries. */
-    dotSubScan(root: any, property: string, fun: (a: any, b: any) => boolean, value: any): boolean;
+    $and(expressionArray: LokiQuery[]): LokiResultset<E>;
 
     /** find() - Used for querying via a mongo-style query object.
+     *
      * @param {object} query - A mongo-style query object used for filtering current results.
      * @param {boolean} firstOnly - (Optional) Used by collection.findOne()
      * @returns {Resultset} this resultset for further chain ops.
      */
+    //find(query: LokiQuery, firstOnly: boolean): E;
     //find(query?: any, firstOnly?: boolean): E[];
     find(query: LokiQuery, firstOnly?: boolean): LokiResultset<E>;
 
     /** where() - Used for filtering via a javascript filter function.
+     *
      * @param {function} fun - A javascript function used for filtering current results by.
      * @returns {Resultset} this resultset for further chain ops.
      */
     where(fun: (obj: E) => boolean): LokiResultset<E>;
 
+    /** count() - returns the number of documents in the resultset.
+     *
+     * @returns {number} The number of documents in the resultset.
+     */
+    count(): number;
+
     /** data() - Terminates the chain and returns array of filtered documents
+     *
+     * @param options {object} : allows specifying 'forceClones' and 'forceCloneMethod' options.
+     *    options :
+     *      forceClones {boolean} : Allows forcing the return of cloned objects even when
+     *        the collection is not configured for clone object.
+     *      forceCloneMethod {string} : Allows overriding the default or collection specified cloning method.
+     *        Possible values include 'parse-stringify', 'jquery-extend-deep', and 'shallow'
+     *
      * @returns {array} Array of documents in the resultset
      */
-    data(): E[];
+    data(options?: { forceClones?: string; forceCloneMethod?: string; }): E[];
 
     /** update() - used to run an update operation on all documents currently in the resultset.
-    * @param {function} updateFunction - User supplied updateFunction(obj) will be executed for each document object.
-    * @returns {Resultset} this resultset for further chain ops.
-    */
-    update<U>(updateFunction: (obj: E) => U): LokiResultset<U>;
+     *
+     * @param {function} updateFunction - User supplied updateFunction(obj) will be executed for each document object.
+     * @returns {Resultset} this resultset for further chain ops.
+     */
+    update(updateFunction: (obj: E) => void): LokiResultset<E>;
 
     /** remove() - removes all document objects which are currently in resultset from collection (as well as resultset)
+     *
      * @returns {Resultset} this (empty) resultset for further chain ops.
      */
     remove(): LokiResultset<E>;
 
     /** mapReduce() - data transformation via user supplied functions
+     *
      * @param {function} mapFunction - this function accepts a single document for you to transform and return
      * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value
      * @returns The output of your reduceFunction
@@ -407,76 +518,94 @@ interface LokiResultset<E> {
      * @param {function} (optional) mapFun - A function that receives each matching pair and maps them into output objects - function(left,right){return joinedObject}
      * @returns {Resultset} A resultset with data in the format [{left: leftObj, right: rightObj}]
      */
-    eqJoin<T, U>(joinData: T[]| LokiResultset<T>, leftJoinKey: string | ((obj: T) => string), rightJoinKey: string | ((obj: E) => string)): LokiResultset<{ left: E; right: T; }>;
-    eqJoin<T, U>(joinData: T[]| LokiResultset<T>, leftJoinKey: string | ((obj: T) => string), rightJoinKey: string | ((obj: E) => string), mapFun?: (a: E, b: T) => U): LokiResultset<U>;
-
-    map<U>(mapFun: (currentValue: E, index: number, array: E[]) => U): LokiResultset<U>;
+    eqJoin<T>(joinData: T[] | LokiResultset<T>, leftJoinKey: string | ((obj: E) => string), rightJoinKey: string | ((obj: T) => string)): LokiResultset<{ left: E; right: T; }>;
+    eqJoin<T, U>(joinData: T[] | LokiResultset<T>, leftJoinKey: string | ((obj: E) => string), rightJoinKey: string | ((obj: T) => string), mapFun?: (a: E, b: T) => U): LokiResultset<U>;
 
+    map<T>(mapFun: (currentValue: E, index: number, array: E[]) => T): LokiResultset<T>;
 }
 
 
 
 
 /** DynamicView class is a versatile 'live' view class which can have filters and sorts applied.
- *     Collection.addDynamicView(name) instantiates this DynamicView object and notifies it
- *     whenever documents are add/updated/removed so it can remain up-to-date. (chainable)
- *   Examples:
- *     var mydv = mycollection.addDynamicView('test');  // default is non-persistent
- *     mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });
- *     mydv.applyFind({ 'doors' : 4 });
- *     var results = mydv.data();
- * @param {Collection} collection - A reference to the collection to work against
- * @param {string} name - The name of this dynamic view
- * @param {boolean} persistent - (Optional) If true, the results will be copied into an internal array for read efficiency or binding to.
+ *    Collection.addDynamicView(name) instantiates this DynamicView object and notifies it
+ *    whenever documents are add/updated/removed so it can remain up-to-date. (chainable)
+ *
+ *    Examples:
+ *    var mydv = mycollection.addDynamicView('test');  // default is non-persistent
+ *    mydv.applyWhere(function(obj) { return obj.name === 'Toyota'; });
+ *    mydv.applyFind({ 'doors' : 4 });
+ *    var results = mydv.data();
+ *
  */
 interface LokiDynamicView<E> extends LokiEventEmitter {
-    name: string;
+    cachedresultset: LokiResultset<E>;
     collection: LokiCollection<E>;
+    events: { [id: string]: ((...args: any[]) => void)[] }; /*{
+        'rebuild': ((...args) => void)[];
+    };*/
+    // keep ordered filter pipeline
+    filterPipeline: LokiFilter<E>[];
+    minRebuildInterval: number;
+    name: string;
+    options: LokiDynamicViewOptions;
     persistent: boolean;
+    rebuildPending: boolean;
     resultset: LokiResultset<E>;
     resultdata: E[];
     resultsdirty: boolean;
-    cachedresultset: LokiResultset<E>; // TODO type
-    // keep ordered filter pipeline
-    filterPipeline: { type: string/*'find', 'where'*/; value: LokiQuery | ((element: E, index: number, array: E[]) => boolean) }[]; // TODO type
-    // sorting member variables - we only support one active search, applied using applySort() or applySimpleSort()
+    // sorting member variables, we only support one active search, applied using applySort() or applySimpleSort()
     sortFunction: (a: E, b: E) => number;
-    sortCriteria: [string, boolean][]; // TODO type
+    sortCriteria: ([string, boolean] | [string])[];
     sortDirty: boolean;
-    // for now just have 1 event for when we finally rebuilt lazy view
-    // once we refactor transactions, i will tie in certain transactional events
-    events: {
-        "rebuild": any[]; // TODO type
-    };
+    sortPriority: string; // 'persistentSortPriority', 'passive' (will defer the sort phase until they call data(). most efficient overall), 'active' (will sort async whenever next idle. prioritizes read speeds)
 
-    new (collection: LokiCollection<E>, name: string, persistent?: boolean): LokiDynamicView<E>;
+    /**
+     * @constructor
+     * @param {Collection} collection - A reference to the collection to work against
+     * @param {string} name - The name of this dynamic view
+     * @param {object} options - (Optional) Pass in object with 'persistent' and/or 'sortPriority' options.
+     */
+    new <E>(collection: LokiCollection<E>, name: string, options?: LokiDynamicViewOptions): LokiDynamicView<E>;
 
     /** rematerialize() - intended for use immediately after deserialization (loading)
-     *   This will clear out and reapply filterPipeline ops, recreating the view.
-     *   Since where filters do not persist correctly, this method allows
-     *   restoring the view to state where user can re-apply those where filters.
+     *    This will clear out and reapply filterPipeline ops, recreating the view.
+     *    Since where filters do not persist correctly, this method allows
+     *    restoring the view to state where user can re-apply those where filters.
+     *
      * @param {Object} options - (Optional) allows specification of 'removeWhereFilters' option
      * @returns {DynamicView} This dynamic view for further chained ops.
      */
-    rematerialize(options: { removeWhereFilters?: any/*boolean - if prop exists, action occurs*/; }): LokiDynamicView<E>;
+    rematerialize(options?: { removeWhereFilters?: boolean; }): LokiDynamicView<E>;
 
     /** branchResultset() - Makes a copy of the internal resultset for branched queries.
-     *   Unlike this dynamic view, the branched resultset will not be 'live' updated,
-     *   so your branched query should be immediately resolved and not held for future evaluation.
+     *    Unlike this dynamic view, the branched resultset will not be 'live' updated,
+     *    so your branched query should be immediately resolved and not held for future evaluation.
+     *
+     * @param {string|array} transform: Optional name of collection transform, or an array of transform steps
+     * @param {object} parameters: optional parameters (if optional transform requires them)
      * @returns {Resultset} A copy of the internal resultset for branched queries.
      */
-    branchResultset(): LokiResultset<E>;
+    branchResultset(transform?: string | any[], parameters?: any): LokiResultset<E>;
 
-    /** toJSON() - Override of toJSON to avoid circular references */
+    /** toJSON() - Override of toJSON to avoid circular references
+     */
     toJSON(): LokiDynamicView<E>;
 
+    /** removeFilters() - Used to clear pipeline and reset dynamic view to initial state.
+     *     Existing options should be retained.
+     */
+    removeFilters(): void;
+
     /** applySort() - Used to apply a sort to the dynamic view
+     *
      * @param {function} comparefun - a javascript compare function used for sorting
      * @returns {DynamicView} this DynamicView object, for further chain ops.
      */
     applySort(comparefun: (a: E, b: E) => number): LokiDynamicView<E>;
 
     /** applySimpleSort() - Used to specify a property used for view translation.
+     *
      * @param {string} propname - Name of property by which to sort.
      * @param {boolean} isdesc - (Optional) If true, the sort will be in descending order.
      * @returns {DynamicView} this DynamicView object, for further chain ops.
@@ -484,156 +613,279 @@ interface LokiDynamicView<E> extends LokiEventEmitter {
     applySimpleSort(propname: string, isdesc?: boolean): LokiDynamicView<E>;
 
     /** applySortCriteria() - Allows sorting a resultset based on multiple columns.
-     *   Example : dv.applySortCriteria(['age', 'name']); to sort by age and then name (both ascending)
-     *   Example : dv.applySortCriteria(['age', ['name', true]); to sort by age (ascending) and then by name (descending)
-     *   Example : dv.applySortCriteria(['age', true], ['name', true]); to sort by age (descending) and then by name (descending)
+     *    Example : dv.applySortCriteria(['age', 'name']); to sort by age and then name (both ascending)
+     *    Example : dv.applySortCriteria(['age', ['name', true]); to sort by age (ascending) and then by name (descending)
+     *    Example : dv.applySortCriteria(['age', true], ['name', true]); to sort by age (descending) and then by name (descending)
+     *
      * @param {array} properties - array of property names or subarray of [propertyname, isdesc] used evaluate sort order
      * @returns {DynamicView} Reference to this DynamicView, sorted, for future chain operations.
      */
-    applySortCriteria(criteria: string | any[]): LokiDynamicView<E>;
+    applySortCriteria(criteria: ([string, boolean] | [string])[]): LokiDynamicView<E>;
 
     /** startTransaction() - marks the beginning of a transaction.
+     *
      * @returns {DynamicView} this DynamicView object, for further chain ops.
      */
     startTransaction(): LokiDynamicView<E>;
 
     /** commit() - commits a transaction.
+     *
      * @returns {DynamicView} this DynamicView object, for further chain ops.
      */
     commit(): LokiDynamicView<E>;
 
     /** rollback() - rolls back a transaction.
+     *
      * @returns {DynamicView} this DynamicView object, for further chain ops.
      */
     rollback(): LokiDynamicView<E>;
 
-    /** applyFind() - Adds a mongo-style query option to the DynamicView filter pipeline
-     * @param {object} query - A mongo-style query object to apply to pipeline
-     * @returns {DynamicView} this DynamicView object, for further chain ops.
+    /** Implementation detail.
+     * _indexOfFilterWithId() - Find the index of a filter in the pipeline, by that filter's ID.
+     *
+     * @param {string|number} uid - The unique ID of the filter.
+     * @returns {number}: index of the referenced filter in the pipeline; -1 if not found.
      */
-    applyFind(query: LokiQuery): LokiDynamicView<E>;
+    _indexOfFilterWithId(uid: string | number): number;
 
-    /** applyWhere() - Adds a javascript filter function to the DynamicView filter pipeline
-     * @param {function} fun - A javascript filter function to apply to pipeline
+    /** Implementation detail.
+     * _addFilter() - Add the filter object to the end of view's filter pipeline and apply the filter to the resultset.
+     *
+     * @param {object} filter - The filter object. Refer to applyFilter() for extra details.
+     */
+    _addFilter(filter: LokiFilter<E>): void;
+
+    /** reapplyFilters() - Reapply all the filters in the current pipeline.
+     *
      * @returns {DynamicView} this DynamicView object, for further chain ops.
      */
-    applyWhere(fun: (obj: E) => boolean): LokiDynamicView<E>;
+    reapplyFilters(): LokiDynamicView<E>;
+
+    /** applyFilter() - Adds or updates a filter in the DynamicView filter pipeline
+     *
+     * @param {object} filter - A filter object to add to the pipeline.
+     *    The object is in the format { 'type': filter_type, 'val', filter_param, 'uid', optional_filter_id }
+     * @returns {DynamicView} this DynamicView object, for further chain ops.
+     */
+    applyFilter(filter: LokiFilter<E>): LokiDynamicView<E>;
+
+    /** applyFind() - Adds or updates a mongo-style query option in the DynamicView filter pipeline
+     *
+     * @param {object} query - A mongo-style query object to apply to pipeline
+     * @param {string|number} uid - Optional: The unique ID of this filter, to reference it in the future.
+     * @returns {DynamicView} this DynamicView object, for further chain ops.
+     */
+    applyFind(query: LokiQuery, uid?: string | number): LokiDynamicView<E>;
+
+    /** applyWhere() - Adds or updates a javascript filter function in the DynamicView filter pipeline
+     *
+     * @param {function} fun - A javascript filter function to apply to pipeline
+     * @param {string|number} uid - Optional: The unique ID of this filter, to reference it in the future.
+     * @returns {DynamicView} this DynamicView object, for further chain ops.
+     */
+    applyWhere(fun: (obj: E) => boolean, uid?: string | number): LokiDynamicView<E>;
+
+    /** removeFilter() - Remove the specified filter from the DynamicView filter pipeline
+     *
+     * @param {string|number} uid - The unique ID of the filter to be removed.
+     * @returns {DynamicView} this DynamicView object, for further chain ops.
+     */
+    removeFilter(uid: string | number): LokiDynamicView<E>;
+
+    /** count() - returns the number of documents representing the current DynamicView contents.
+     *
+     * @returns {number} The number of documents representing the current DynamicView contents.
+     */
+    count(): number;
 
     /** data() - resolves and pending filtering and sorting, then returns document array as result.
+     *
      * @returns {array} An array of documents representing the current DynamicView contents.
      */
     data(): E[];
 
-    /** */
+    /** queueRebuildEvent() - When the view is not sorted we may still wish to be notified of rebuild events.
+     *     This event will throttle and queue a single rebuild event when batches of updates affect the view.
+     */
+    queueRebuildEvent(): void;
+
+    /** queueSortPhase : If the view is sorted we will throttle sorting to either :
+     *    (1) passive - when the user calls data(), or
+     *    (2) active - once they stop updating and yield js thread control
+     */
     queueSortPhase(): void;
 
-    /** performSortPhase() - invoked synchronously or asynchronously to perform final sort phase (if needed) */
-    performSortPhase(): void;
+    /** performSortPhase() - invoked synchronously or asynchronously to perform final sort phase (if needed)
+     */
+    performSortPhase(options?: { suppressRebuildEvent?: boolean; }): void;
 
     /** evaluateDocument() - internal method for (re)evaluating document inclusion.
-     *   Called by : collection.insert() and collection.update().
+     *    Called by : collection.insert() and collection.update().
+     *
      * @param {int} objIndex - index of document to (re)run through filter pipeline.
+     * @param {bool} isNew - true if the document was just added to the collection.
      */
-    evaluateDocument(objIndex: number): void;
+    evaluateDocument(objIndex: number, isNew?: boolean): void;
 
-    /** removeDocument() - internal function called on collection.delete() */
+    /** removeDocument() - internal function called on collection.delete()
+     */
     removeDocument(objIndex: number): void;
 
     /** mapReduce() - data transformation via user supplied functions
+     *
      * @param {function} mapFunction - this function accepts a single document for you to transform and return
      * @param {function} reduceFunction - this function accepts many (array of map outputs) and returns single value
      * @returns The output of your reduceFunction
      */
-    mapReduce<T, U>(mapFunction: (value: E, index: number, array: E[]) => T, reduceFunction: (array: T[]) => U): U;
-
+    mapReduce<T, U>(mapFunction: (item: E, index: number, array: E[]) => T, reduceFunction: (array: T[]) => U): U;
 }
 
 
 
 
 /** Collection class that handles documents of same type
- * @param {stirng} collection name
- * @param {array} array of property names to be indicized
- * @param {object} configuration object
  */
 interface LokiCollection<E> extends LokiEventEmitter {
-    // the name of the collection
-    name: string;
-    // the data held by the collection
-    data: E[];
-    idIndex: number[]; // index of id
-    binaryIndices: { [id: string]: { name: string; dirty: boolean; values: number[] } }; // user defined indexes
-    constraints: { unique: { [id: string]: LokiUniqueIndex<E> }; exact: { [id: string]: LokiExactIndex<E> }; }
-    // the object type of the collection
-    objType: string;
-    // currentMaxId - change manually at your own peril!
-    maxId: number;
-    DynamicViews: LokiDynamicView<E>[]; // TODO type
-    events: {
-        'insert': any[];
-        'update': any[];
-        'pre-insert': any[];
-        'pre-update': any[];
-        'close': any[];
-        'flushbuffer': any[];
-        'error': any[];
-        'delete': any[];
-        'warning': any[];
+    // option to observe objects and update them automatically, ignored if Object.observe is not supported
+    autoupdate: boolean;
+    // option to make event listeners async, default is sync
+    asyncListeners: boolean;
+    binaryIndices: { [id: string]: { name: string; dirty: boolean; values: number[] } };
+
+    cachedIndex: number[];
+    cachedBinaryIndex: { [id: string]: { name: string; dirty: boolean; values: number[] } };
+    cachedData: E[];
+    // changes are tracked by collection and aggregated by the db
+    changes: LokiCollectionChange[];
+    // default clone method (if enabled) is parse-stringify
+    cloneMethod: string; // 'parse-stringify'
+    // options to clone objects when inserting them
+    cloneObjects: boolean;
+    console: {
+        log: () => void;
+        warn: () => void;
+        error: () => void;
     };
+    constraints: {
+        unique: { [id: string]: LokiUniqueIndex<E> };
+        exact: { [id: string]: LokiExactIndex<E> };
+    };
+    data: E[];
     // in autosave scenarios we will use collection level dirty flags to determine whether save is needed.
     // currently, if any collection is dirty we will autosave the whole database if autosave is configured.
     // defaulting to true since this is called from addCollection and adding a collection should trigger save
     dirty: boolean;
-    // changes are tracked by collection and aggregated by the db
-    changes: { name: string; operation: string/*'I', 'U', 'R'*/; obj: any }[];
-    // private holders for cached data
-    cachedIndex: any; // TODO type
-    cachedBinaryIndex: any; // TODO type
-    cachedData: any; // TODO type
-    // options
-    transactional: boolean;
-    cloneObjects: boolean;
-    asyncListeners: boolean;
+    // disable track changes
     disableChangesApi: boolean;
-    setChangesApi: (enabled: boolean) => void;
+    DynamicViews: LokiDynamicView<E>[];
+    events: { [id: string]: ((...args: any[]) => void)[] }; /*{
+        'insert': ((...args) => void)[];
+        'update': ((...args) => void)[];
+        'pre-insert': ((...args) => void)[];
+        'pre-update': ((...args) => void)[];
+        'close': ((...args) => void)[];
+        'flushbuffer': ((...args) => void)[];
+        'error': ((...args) => void)[];
+        'delete': ((...args) => void)[];
+        'warning': ((...args) => void)[];
+    };*/
+    idIndex: number[];
+    maxId: number; // currentMaxId - change manually at your own peril!
+    name: string;
+    // is collection transactional
+    transactional: boolean;
+    objType: string;
+    // transforms will be used to store frequently used query chains as a series of steps
+    // which itself can be stored along with the database.
+    transforms: { [id: string]: any };
+    // unique contraints contain duplicate object references, so they are not persisted.
+    // we will keep track of properties which have unique contraint applied here, and regenerate on load
+    uniqueNames: string[];
 
-    new (name: string, options?: LokiCollectionOptions): LokiCollection<E>;
+    options: LokiCollectionOptions;
+
+    // option to activate a cleaner daemon - clears "aged" documents at set intervals.
+    ttl: {
+        age: number;
+        ttlInterval: number;
+        daemon: number;
+    };
+
+    /** Collection class that handles documents of same type
+     * @constructor
+     * @param {string} collection name
+     * @param {array} array of property names to be indicized
+     * @param {object} configuration object
+     */
+    new <E>(name: string, options?: LokiCollectionOptions): LokiCollection<E>;
 
     getChanges(): LokiCollectionChange[];
 
+    setChangesApi(enabled: boolean): void;
+
     flushChanges(): void;
 
-    byExample(template: any): { $and: any[] };
+    observerCallback: (changes: { object: any }[]) => void;
+
+    addAutoUpdateObserver(object: any): void;
+
+    removeAutoUpdateObserver(object: any): void;
+
+    addTransform(name: string, transform: any): void;
+
+    setTransform(name: string, transform: any): void;
+
+    removeTransform(name: string): void;
+
+    byExample(template: any): { '$and': any[] };
 
     findObject(template: any): E;
 
     findObjects(template: any): E[];
 
+    /*----------------------------+
+    | TTL daemon                  |
+    +----------------------------*/
+    ttlDaemonFuncGen(): () => void;
+
+    setTTL(age: number, interval: number): void;
 
     /*----------------------------+
     | INDEXING                    |
     +----------------------------*/
 
-    /** Ensure binary index on a certain field */
+    /**
+     * create a row filter that covers all documents in the collection
+     */
+    prepareFullDocIndex(): number[];
+
+    /** Ensure binary index on a certain field
+     */
     ensureIndex(property: string, force?: boolean): void;
 
-    ensureUniqueIndex(field: string): void;
+    ensureUniqueIndex(field: string): LokiUniqueIndex<E>;
 
-    /** Ensure all binary indices */
+    /** Ensure all binary indices
+     */
     ensureAllIndexes(force?: boolean): void;
 
     flagBinaryIndexesDirty(): void;
 
-    count(): number;
+    flagBinaryIndexDirty(index: string): void;
 
-    /** Rebuild idIndex */
+    count(query?: LokiQuery): number;
+
+    /** Rebuild idIndex
+     */
     ensureId(): void;
 
-    /** Rebuild idIndex async with callback - useful for background syncing with a remote server */
+    /** Rebuild idIndex async with callback - useful for background syncing with a remote server
+     */
     ensureIdAsync(callback: () => void): void;
 
-    /** Each collection maintains a list of DynamicViews associated with it */
-    addDynamicView(name: string, persistent?: boolean): LokiDynamicView<E>;
+    /** Each collection maintains a list of DynamicViews associated with it
+     **/
+    addDynamicView(name: string, options?: LokiDynamicViewOptions): LokiDynamicView<E>;
 
     removeDynamicView(name: string): void;
 
@@ -644,61 +896,78 @@ interface LokiCollection<E> extends LokiEventEmitter {
      */
     findAndUpdate(filterFunction: (obj: E) => boolean, updateFunction: (obj: E) => E): void;
 
-    /** generate document method - ensure objects have id and objType properties
-     * @param {object} the document to be inserted (or an array of objects)
+    /** generate document method - ensure object(s) have meta properties, clone it if necessary, etc.
+     * @param {object} doc: the document to be inserted (or an array of objects)
      * @returns document or documents (if passed an array of objects)
      */
     insert(doc: E): E;
     insert(doc: E[]): E[];
 
+    /** generate document method - ensure object has meta properties, clone it if necessary, etc.
+     * @param {object} the document to be inserted
+     * @returns document or 'undefined' if there was a problem inserting it
+     */
+    insertOne(doc: E): E;
+
     clear(): void;
 
-    /** Update method */
-    update(doc: E): void;
+    /** Update method
+     */
+    update(doc: E): E;
+    update(doc: E[]): void;
 
-    /** Add object to collection */
+    /** Add object to collection
+     */
     add(obj: E): E;
 
     removeWhere(query: ((obj: E) => boolean) | LokiQuery): void;
 
     removeDataOnly(): void;
 
-    /** delete wrapped */
-    remove(doc: E | E[]| number | number[]): E;
-
+    /** delete wrapped
+     */
+    remove(doc: E): E;
+    remove(doc: number): E;
+    remove(doc: number[]): void;
+    remove(doc: E[]): void;
 
     /*---------------------+
     | Finding methods     |
     +----------------------*/
 
-    /** Get by Id - faster than other methods because of the searching algorithm */
+    /** Get by Id - faster than other methods because of the searching algorithm
+     */
     get(id: number | string): E;
-    //get(id: number | string, returnPosition: true): [E, number];
-    get(id: number | string, returnPosition: boolean): E |[E, number];
+    get(id: number | string, returnPosition?: boolean): E | [E, number];
 
     by(field: string): (value: any) => E;
-    by(field: string, value?: string): E;
+    by(field: string, value: string): E;
 
-    /** Find one object by index property, by property equal to value */
+    /** Find one object by index property, by property equal to value
+     */
     findOne(query: LokiQuery): E;
 
     /** Chain method, used for beginning a series of chained find() and/or view() operations
      * on a collection.
+     *
+     * @param {array} transform : Ordered array of transform step objects similar to chain
+     * @param {object} parameters: Object containing properties representing parameters to substitute
+     * @returns {Resultset} : (or data array if any map or join functions where called)
      */
-    chain(): LokiResultset<E>;
+    chain(transform?: string | any[], parameters?: any): LokiResultset<E>;
 
-    /** Find method, api is similar to mongodb except for now it only supports one search parameter.
+    /**
+     * Find method, api is similar to mongodb except for now it only supports one search parameter.
      * for more complex queries use view() and storeView()
      */
-    find(): LokiResultset<E>;
-    find(query: LokiQuery): E[];
+    find(): E[];
+    find(query: LokiQuery): LokiResultset<E>;
 
     /** Find object by unindexed field by property equal to value,
      * simply iterates and returns the first element matching the query
      */
     findOneUnindexed(prop: string, value: any): E;
 
-
     /** Transaction methods */
 
     /** start the transation */
@@ -713,16 +982,18 @@ interface LokiCollection<E> extends LokiEventEmitter {
     // async executor. This is only to enable callbacks at the end of the execution.
     async(fun: () => void, callback: () => void): void;
 
-    /** Create view function - filter */
+    /** Create view function - filter
+     */
     where(fun: (obj: E) => boolean): LokiResultset<E>;
 
-    /** Map Reduce */
-    mapReduce<T, U>(mapFunction: (value: E, index: number, array: E[]) => T, reduceFunction: (previousValue: U, currentValue: T, index: number, array: T[]) => U): U;
-
-    /** eqJoin - Join two collections on specified properties */
-    eqJoin<T, U>(joinData: T[]| LokiResultset<T>, leftJoinProp: string | ((obj: T) => string), rightJoinProp: string | ((obj: E) => string)): LokiResultset<{ left: E; right: T; }>;
-    eqJoin<T, U>(joinData: T[]| LokiResultset<T>, leftJoinProp: string | ((obj: T) => string), rightJoinProp: string | ((obj: E) => string), mapFun?: (a: E, b: T) => U): LokiResultset<U>;
+    /** Map Reduce
+     */
+    mapReduce<U, V>(mapFunction: (item: E, index: number, array: E[]) => U, reduceFunction: (array: U[]) => V): V;
 
+    /** eqJoin - Join two collections on specified properties
+     */
+    eqJoin<T>(joinData: T[] | LokiResultset<T>, leftJoinProp: string | ((obj: E) => string), rightJoinProp: string | ((obj: T) => string)): LokiResultset<{ left: E; right: T; }>;
+    eqJoin<T, U>(joinData: T[] | LokiResultset<T>, leftJoinProp: string | ((obj: E) => string), rightJoinProp: string | ((obj: T) => string), mapFun?: (a: E, b: T) => U): LokiResultset<U>;
 
     /* ------ STAGING API -------- */
     /** stages: a map of uniquely identified 'stages', which hold copies of objects to be
@@ -730,14 +1001,21 @@ interface LokiCollection<E> extends LokiEventEmitter {
      */
     stages: { [id: string]: any };
 
-    /** create a stage and/or retrieve it */
-    getStage(name: string): any;
+    /** create a stage and/or retrieve it
+     */
+    getStage(name: string): E[];
 
-    /** a collection of objects recording the changes applied through a commmitStage */
-    commitLog: { timestamp: number; message: any; data: any }[];
+    /** a collection of objects recording the changes applied through a commmitStage
+     */
+    commitLog: {
+        timestamp: number; // timestamp (i.e. new Date().getTime())
+        message: any;
+        data: E;
+    }[];
 
-    /** create a copy of an object and insert it into a stage */
-    stage<T>(stageName: string, obj: T): T;
+    /** create a copy of an object and insert it into a stage
+     */
+    stage(stageName: string, obj: E): E;
 
     /** re-attach all objects to the original collection, so indexes and views can be rebuilt
      * then create a message to be inserted in the commitlog
@@ -762,80 +1040,187 @@ interface LokiCollection<E> extends LokiEventEmitter {
 
     stdDev(field: string): number;
 
-    mode(field: string): number;
+    mode(field: string): string | number;
 
     median(field: string): number;
 }
 
 
-/*
-interface Utils {
-    copyProperties(src, dest): void;
-}
-    
-// Sort helper that support null and undefined
-function ltHelper(prop1, prop2, equal?: boolean): boolean;
-    
-function gtHelper(prop1, prop2, equal?: boolean): boolean;
-    
-function sortHelper(prop1, prop2, desc?: boolean): number;
-    
-function containsCheckFn<T>(a: T[], b): (curr: T) => boolean;
-    
-function containsCheckFn(a: string, b): (curr: string) => boolean;
-    
-function containsCheckFn<T>(a: T, b): (curr: string) => boolean;
-    
-function clone<T>(data: T, method?: string): T;
-    
-function localStorageAvailable(): boolean;
-*/
-
-
-/** General utils, including statistical functions */
-/*
-function isDeepProperty(field: string): boolean;
-    
-function parseBase10(num: number | string): number;
-    
-function isNotUndefined(obj: any): boolean;
-    
-function add(a: number, b: number): number;
-    
-function sub(a: number, b: number): number;
-    
-function median(values: number[]): number;
-    
-function average(array: number[]): number;
-    
-function standardDeviation(values: number[]): number;
-*/
 
 
+/** comparison operators
+ * a is the value in the collection
+ * b is the query value
+ */
 interface LokiOps {
-    // comparison operators
-    $eq: (a: any, b: any) => boolean;
-    $gt: (a: any, b: any) => boolean;
-    $gte: (a: any, b: any) => boolean;
-    $lt: (a: any, b: any) => boolean;
-    $lte: (a: any, b: any) => boolean;
-    $ne: (a: any, b: any) => boolean;
-    $regex: (a: string, b: RegExp) => boolean;
-    $in: (a: any, b: { indexOf: (value: any) => number }) => boolean;
-    $containsAny: (a: any, b: any[]| any) => boolean;
-    $contains: (a: any, b: any[]| any) => boolean;
-}
-
-//declare var operators: LokiOps;
-
-
-interface LokiDeepProperty {
-    (obj: any, property: string, isDeep?: boolean): any;
+    $eq(a: any, b: any): boolean;
+    $ne(a: any, b: any): boolean;
+    $dteq(a: any, b: any): boolean;
+    $gt(a: any, b: any): boolean;
+    $gte(a: any, b: any): boolean;
+    $lt(a: any, b: any): boolean;
+    $lte(a: any, b: any): boolean;
+    $in(a: any, b: { indexOf: (value: any) => boolean }): boolean;
+    $nin(a: any, b: { indexOf: (value: any) => boolean }): boolean;
+    $keyin(a: string, b: any): boolean;
+    $nkeyin(a: string, b: any): boolean;
+    $definedin(a: any, b: any): boolean;
+    $undefinedin(a: any, b: any): boolean;
+    $regex(a: any, b: RegExp | { test: (str: string) => boolean }): boolean;
+    $containsString(a: string | any, b: string): boolean;
+    $containsNone(a: any, b: any): boolean;
+    $containsAny(a: any, b: any | any[]): boolean;
+    $contains(a: any, b: any | any[]): boolean;
+    $type(a: any, b: any): boolean;
+    $size(a: any, b: any): boolean;
+    $len(a: any, b: any): boolean;
+    // field-level logical operators
+    // a is the value in the collection
+    // b is the nested query operation (for '$not')
+    //   or an array of nested query operations (for '$and' and '$or')
+    $not(a: any, b: any): boolean;
+    $and(a: any, b: any[]): boolean;
+    $or(a: any, b: any[]): boolean;
 }
 
 
-interface LokiBinarySearch<T> {
-    (array: T[], item: T, fun: (a: T, b: T) => number): { found: boolean; index: number; };
+interface LokiKeyValueStore<K, V> {
+    keys: K[];
+    values: V[];
+
+    sort(a: any, b: any): number;
+    setSort(fun: (a: K, b: K) => number): void;
+    bs(): LokiBSonSort<K>;
+    set(key: K, value: V): void;
+    get(key: K): V;
+}
+
+
+interface LokiUniqueIndex<E> {
+    field: string;
+    keyMap: { [id: string]: E };
+    lokiMap: { [id: number]: any };
+
+    new <E>(uniqueField: string): LokiUniqueIndex<E>;
+
+    set(obj: E): void;
+    get(key: string): E;
+    byId(id: number): E;
+    update(obj: E): void;
+    remove(key: string): void;
+    clear(): void;
+}
+
+
+interface LokiExactIndex<E> {
+    index: { [id: string]: E[] };
+    field: string;
+
+    new <E>(exactField: string): LokiExactIndex<E>
+
+    /** add the value you want returned to the key in the index */
+    set(key: string, val: E): void;
+    /** remove the value from the index, if the value was the last one, remove the key */
+    remove(key: string, val: E): void;
+    /** get the values related to the key, could be more than one */
+    get(key: string): E[];
+    /** clear will zap the index */
+    clear(key?: any): void;
+}
+
+
+interface LokiSortedIndex<K, V> {
+    field: string;
+    keys: K[];
+    values: V[][];
+
+    new <K, V>(sortedField: string): LokiSortedIndex<K, V>;
+
+    // set the default sort
+    sort(a: any, b: any): number;
+    bs(): LokiBSonSort<any>;
+    // and allow override of the default sort
+    setSort(fun: (a: any, b: any) => number): void;
+    // add the value you want returned  to the key in the index
+    set(key: K, value: V): void;
+    // get all values which have a key == the given key
+    get(key: K): V[];
+    // get all values which have a key < the given key
+    getLt(key: K): V[];
+    // get all values which have a key > the given key
+    getGt(key: K): V[];
+    // get all vals from start to end
+    getAll(key: K, start: number, end: number): V[];
+    // just in case someone wants to do something smart with ranges
+    getPos(key: K): { found: boolean; index: number; };
+    // remove the value from the index, if the value was the last one, remove the key
+    remove(key: K, value: V): void;
+    // clear will zap the index
+    clear(): void;
+}
+
+
+interface LokiConfigureOptions {
+    adapter?: LokiPersistenceInterface;
+    autoload?: boolean;
+    autoloadCallback?: (dataOrErr: any | Error) => void;
+    autosave?: boolean;
+    autosaveCallback?: (err: any) => void;
+    autosaveInterval?: number; // milliseconds between auto-saves
+    env?: string; /*'NODEJS', 'BROWSER', 'CORDOVA'*/
+    persistenceMethod?: string; /*'fs', 'localStorage', 'adapter'*/
+    verbose?: boolean;
+}
+
+
+interface LokiCollectionOptions {
+    asyncListeners?: boolean;
+    autoupdate?: boolean;
+    clone?: boolean;
+    cloneMethod?: string;
+    disableChangesApi?: boolean;
+    exact?: string[];
+    indices?: string | string[];
+    transactional?: boolean;
+    unique?: string | string[];
+}
+
+
+interface LokiDynamicViewOptions {
+    minRebuildInterval?: number;
+    persistent?: boolean;
+    sortPriority: string; /*'active', 'passive'*/
+}
+
+
+interface LokiResultsetOptions<E> {
+    firstOnly?: boolean;
+    queryObj?: LokiQuery;
+    queryFunc?: (item: E) => boolean;
+}
+
+
+interface LokiQuery {
+}
+
+
+interface LokiFilter<E> {
+    type: string; /*'find', 'where'*/
+    val: LokiQuery | ((obj: E, index: number, array: E[]) => boolean);
+    uid: number | string;
+}
+
+
+interface LokiElementMetaData {
+    created: number; // unix style timestamp (i.e. new Date().getTime())
+    revision: number;
+}
+
+
+interface LokiCollectionChange {
+    name: string;
+    operation: string;/*'I', 'R', 'U'*/
+    obj: any;
 }
 
 
@@ -844,140 +1229,82 @@ interface LokiBSonSort<T> {
 }
 
 
+/*
+interface LokiUtils {
+    copyProperties(src: any, dest: any): void;
 
+    // used to recursively scan hierarchical transform step object for param substitution
+    resolveTransformObject<U>(subObj: U, params: any, depth?: number): U;
 
-interface LokiKeyValueStore<K, V> {
-    keys: K[];
-    values: V[];
-
-    sort(a: K, b: K): number;
-    setSort(fun: (a: K, b: K) => number): void;
-    bs(): LokiBSonSort<K>;
-    set(key: K, value: V): void;
-    get(key: K): V;
+    // top level utility to resolve an entire (single) transform (array of steps) for parameter substitution
+    resolveTransformParams<U>(transform: U[], params: any): U[];
 }
 
+// Sort helper that support null and undefined
+declare function ltHelper(prop1: any, prop2: any, equal?: boolean): boolean;
 
+declare function gtHelper(prop1: any, prop2: any, equal?: boolean): boolean;
 
+declare function sortHelper(prop1: any, prop2: any, desc?: boolean): number;
 
-interface LokiUniqueIndex<E> {
-    field: string;
-    keyMap: { [id: string]: E };
-    lokiMap: { [id: number]: any }; // 'field' map
+declare function doQueryOp(val: any, op: any): boolean;
 
-    new (uniqueField: string): LokiUniqueIndex<E>;
+declare function containsCheckFn<T>(a: T[], b): (curr: T) => boolean;
+declare function containsCheckFn(a: string, b): (curr: string) => boolean;
+declare function containsCheckFn<T>(a: T, b): (curr: string) => boolean;
+*/
 
-    set(obj: E): void;
+/** General utils, including statistical functions
+ */
+/*
+declare function isDeepProperty(field: string): boolean;
 
-    get(key: string): E;
+declare function parseBase10(num: string | number): number;
 
-    byId(id: number): E;
+declare function isNotUndefined(obj: any): boolean;
 
-    update(obj: E): void;
+declare function add(a: string | number, b: string | number): number;
 
-    remove(key: string): void;
+declare function sub(a: string | number, b: string | number): number;
 
-    clear(): void;
-}
+declare function median(values: number[]): number;
+
+declare function average(array: (string | number)[]);
+
+declare function standardDeviation(values: (string | number)[]): number;
+
+declare function deepProperty(obj: any, property: string, isDeep?: boolean): any;
+
+declare function binarySearch<U>(array: U[], item: U, fun: (a: U, b: U) => number): { found: boolean; index: number; };
+
+// compoundeval() - helper function for compoundsort(), performing individual object comparisons
+//
+// @param {array} properties - array of property names, in order, by which to evaluate sort order
+// @param {object} obj1 - first object to compare
+// @param {object} obj2 - second object to compare
+// @returns {integer} 0, -1, or 1 to designate if identical (sortwise) or which should be first
+declare function compoundeval(properties: ([string, boolean] | [string])[], obj1: any, obj2: any): number;
+
+// dotSubScan - helper function used for dot notation queries.
+declare function dotSubScan<V>(root: any | any[], propPath: string[], fun: (root, value: V) => boolean, value: V): boolean;
+
+// making indexing opt-in... our range function knows how to deal with these ops :
+//var indexedOpsList = ['$eq', '$dteq', '$gt', '$gte', '$lt', '$lte'];
+
+declare function clone<U>(data: U, method?: string): U; // stage: 'parse-stringify', 'jquery-extend-deep', 'shallow'
+
+declare function cloneObjectArray<U>(objarray: U[], method?: string): U; // stage: 'parse-stringify', 'jquery-extend-deep', 'shallow'
+
+declare function localStorageAvailable(): boolean;
+*/
 
 
 
 
-interface LokiExactIndex<E> {
-    index: { [id: string]: E[] };
-    field: string;
-
-    new <E>(exactField: string): LokiExactIndex<E>;
-
-    // add the value you want returned to the key in the index 
-    set(key: string, val: E): void;
-
-    // remove the value from the index, if the value was the last one, remove the key
-    remove(key: string, val: E): void;
-
-    // get the values related to the key, could be more than one
-    get(key: string): E[];
-
-    // clear will zap the index
-    clear(key?: any): void;
-}
-
-
-
-interface LokiSortedIndex<K, V> {
-    keys: K[];
-    values: V[];
-
-    new (sortedField: string): LokiSortedIndex<K, V>;
-
-    // set the default sort
-    sort(a: K, b: K): number;
-    bs(): LokiBSonSort<K>;
-    // and allow override of the default sort
-    setSort(fun: (a: K, b: K) => number): void;
-    // add the value you want returned  to the key in the index  
-    set(key: K, value: V): void;
-    // get all values which have a key == the given key
-    get(key: K): V | V[];
-    // get all values which have a key < the given key
-    getLt(key: K): V[];
-    // get all values which have a key > the given key
-    getGt(key: K): V[];
-
-    // get all vals from start to end
-    getAll(key: K, start: number, end: number): V[];
-    // just in case someone wants to do something smart with ranges
-    getPos(key: K): boolean;
-    // remove the value from the index, if the value was the last one, remove the key
-    remove(key: K, value: V): void;
-    // clear will zap the index
-    clear(key?: any): void;
-}
-
-
-interface LokiPersistenceInterface {
-    loadDatabase: (fileName: string, func: (dbString: string) => void) => void;
-    saveDatabase: (fileName: string, content: string, func: () => void) => void;
-}
-
-
-interface LokiConfigureOptions {
-    env?: string/*'NODEJS', 'BROWSER', 'CORDOVA'*/;
-    persistenceMethod?: string/*'fs', 'localStorage'*/;
-    adapter?: LokiPersistenceInterface;
-    autoload?: any;
-    autoloadCallback?: (err: Error | string, data: any) => void;
-    autosave?: boolean;
-    autosaveInterval?: number;
-}
-
-
-interface LokiQuery {
-}
-
-
-interface LokiCollectionChange {
-    name: string;
-    operation: string/*'I', 'U', 'R'*/;
-    obj: any
-}
-
-
-interface LokiCollectionOptions {
-    transactional?: boolean;
-    clone?: boolean;
-    asyncListeners?: boolean;
-    disableChangesApi?: boolean;
-    indices?: string | string[];
-}
-
-
-
-
-/* ==== loki-indexed-adapter.js ==== */
+/* ======== loki-indexed-adapter.js ======== */
 interface LokiIndexedAdapter {
     app: string;
-    catalog: LokiCatalog; // TODO type
+    catalog: LokiCatalog;
 
     /** IndexedAdapter - Loki persistence adapter class for indexedDb.
      *     This class fulfills abstract adapter interface which can be applied to other storage methods
@@ -1005,10 +1332,10 @@ interface LokiIndexedAdapter {
      * @param {string} dbstring - the serialized db string to save.
      * @param {function} callback - (Optional) callback passed obj.success with true or false
      */
-    saveDatabase(dbname: string, dbstring: string, callback?: (res: { success: boolean }) => void): void;
+    saveDatabase(dbname: string, dbstring: string, callback?: (err: Error | void) => void): void;
 
     // alias for saveDatabase
-    saveKey(dbname: string, dbstring: string, callback?: (res: { success: boolean }) => void): void;
+    saveKey(dbname: string, dbstring: string, callback?: (err: Error | void) => void): void;
 
     /** deleteDatabase() - Deletes a serialized db from the catalog.
      * @param {string} dbname - the name of the database to delete from the catalog.
@@ -1030,7 +1357,6 @@ interface LokiIndexedAdapter {
      * @param {function} callback - (Optional) callback to accept result array.
      */
     getCatalogSummary(callback: (entries: { app: string; key: string; size: number; }) => void): void;
-
 }
 
 
@@ -1057,24 +1383,30 @@ interface LokiCatalog {
 
     // Hide 'cursoring' and return array of { id: id, key: key }
     getAllKeys(callback: (data: any[]) => void): void;
-
 }
-/* ==== END loki-indexed-adapter.js ==== */
+/* ======== END loki-indexed-adapter.js ======== */
 
 
 
-/* ==== loki-crypted-file-adapter.js ==== */
-interface LokiCryptedFileAdapterEncryptResult {
-    cipher: string;
-    keyDerivation: string;
-    keyLength: number;
-    iterations: number;
-    iv: string;
-    salt: string;
-    value: string;
-}
+/* ======== loki-crypted-file-adapter.js ======== */
+/**
+ * @file lokiCryptedFileAdapter.js
+ * @author Hans Klunder <Hans.Klunder@bigfoot.com>
+ */
 
+/** require libs */
+//var fs = require('fs');
+//var cryptoLib = require('crypto');
+//var isError = require('util').isError;
 
+/* The default Loki File adapter uses plain text JSON files. This adapter crypts the database string and wraps the result
+* in a JSON including enough info to be able to decrypt it (except for the 'secret' of course !)
+*
+* The idea is that the 'secret' does not reside in your source code but is supplied by some other source (e.g. the user in node-webkit)
+*
+* The idea + encrypt/decrypt routines are borrowed from  https://github.com/mmoulton/krypt/blob/develop/lib/krypt.js
+* not using the krypt module to avoid third party dependencies
+*/
 interface LokiCryptedFileAdapter {
     secret: string;
 
@@ -1084,56 +1416,69 @@ interface LokiCryptedFileAdapter {
     new (): LokiCryptedFileAdapter;
 
     /** setSecret() - set the secret to be used during encryption and decryption
+     *
      * @param {string} secret - the secret to be used
      */
     setSecret(secret: string): void;
 
     /** loadDatabase() - Retrieves a serialized db string from the catalog.
+     *
      *  @example
-     // LOAD
-     var cryptedFileAdapter = require('./lokiCryptedFileAdapter');
-     ptedFileAdapter.setSecret('mySecret'); // you should change 'mySecret' to something supplied by the user
-     var db = new loki('test.crypted', { adapter: cryptedFileAdapter }); //you can use any name, not just '*.crypted'
-     db.loadDatabase(function(result) {
-         e.log('done');
-         
+      // LOAD
+        var cryptedFileAdapter = require('./lokiCryptedFileAdapter');
+        cryptedFileAdapter.setSecret('mySecret'); // you should change 'mySecret' to something supplied by the user
+        var db = new loki('test.crypted', { adapter: cryptedFileAdapter }); //you can use any name, not just '*.crypted'
+        db.loadDatabase(function(result) {
+            console.log('done');
+        });
      *
      * @param {string} dbname - the name of the database to retrieve.
      * @param {function} callback - callback should accept string param containing serialized db string.
      */
-    loadDatabase(dbname: string, callback?: (res: string | Error) => void): void;
+    loadDatabase(dbname: string, callback: (decryptedDataOrErr: string | any) => void): void;
 
     /**
+     *
      @example
-     // SAVE : will save database in 'test.crypted'
-         cryptedFileAdapter = require('./lokiCryptedFileAdapter');
-     ptedFileAdapter.setSecret('mySecret'); // you should change 'mySecret' to something supplied by the user
-         loki=require('lokijs');
-         db = new loki('test.crypted',{ adapter: cryptedFileAdapter }); //you can use any name, not just '*.crypted'
-         coll = db.addCollection('testColl');
-     l.insert({test: 'val'});
-     saveDatabase();  // could pass callback if needed for async complete
- 	
-         ample
-     // if you have the krypt module installed you can use:
-     pt --decrypt test.crypted --secret mySecret
-     to view the contents of the database
- 	
+      // SAVE : will save database in 'test.crypted'
+        var cryptedFileAdapter = require('./lokiCryptedFileAdapter');
+        cryptedFileAdapter.setSecret('mySecret'); // you should change 'mySecret' to something supplied by the user
+        var loki=require('lokijs');
+        var db = new loki('test.crypted',{ adapter: cryptedFileAdapter }); //you can use any name, not just '*.crypted'
+        var coll = db.addCollection('testColl');
+        coll.insert({test: 'val'});
+        db.saveDatabase();  // could pass callback if needed for async complete
+
+     @example
+      // if you have the krypt module installed you can use:
+        krypt --decrypt test.crypted --secret mySecret
+      to view the contents of the database
+
      * saveDatabase() - Saves a serialized db to the catalog.
      *
      * @param {string} dbname - the name to give the serialized database within the catalog.
      * @param {string} dbstring - the serialized db string to save.
      * @param {function} callback - (Optional) callback passed obj.success with true or false
      */
-    saveDatabase(dbname: string, dbstring: string, callback?: (err?: any | LokiCryptedFileAdapterEncryptResult) => void): void;
-
+    saveDatabase(dbname: string, dbstring: string, callback: (err: any) => void): void;
 }
-/* ==== END loki-crypted-file-adapter.js ==== */
+
+
+interface LokiCryptedFileAdapterEncryptResult {
+    cipher: string;
+    keyDerivation: string;
+    keyLength: number;
+    iterations: number;
+    iv: string;
+    salt: string;
+    value: string;
+}
+/* ======== END loki-crypted-file-adapter.js ======== */
 
 
 
 
-/* ==== loki-angular.js ==== */
+/* ======== loki-angular.js ======== */
 /* introduces a angular module named lokijs that returns the 'lokijs' module
     var module = angular.module('lokijs', [])
         .factory('Loki', function Loki() {
@@ -1141,49 +1486,84 @@ interface LokiCryptedFileAdapter {
         });
     return module;
 */
-/* ==== END loki-angular.js ==== */
+/* ======== END loki-angular.js ======== */
 
 
 
 
-/* ==== jquery-sync-adapter.js ==== */
+/* ======== jquery-sync-adapter.js ======== */
+
+/** LokiJS JquerySyncAdapter
+ * A remote sync adapter example for LokiJS
+ * @author Joe Minichino <joe.minichino@gmail.com>
+ */
+
 /** this adapter assumes an object options is passed,
  * containing the following properties:
  * ajaxLib: jquery or compatible ajax library
  * save: { url: the url to save to, dataType [optional]: json|xml|etc., type [optional]: POST|GET|PUT}
  * load: { url: the url to load from, dataType [optional]: json|xml| etc., type [optional]: POST|GET|PUT }
  */
-interface JquerySyncAdapter {
-    options: {
-        ajaxLib: {
-            ajax(options: any): any;
-        };
-        save: {
-            type?: string/*'GET', 'POST, 'DELETE', etc.*/;
-            dataType?: string/*'json', 'xml', etc.*/
-            url?: string
-        };
-    }; // TODO type
+interface LokiJquerySyncAdapter {
+    options: LokiJquerySyncAdapterOptions
 
-    new (options: any): JquerySyncAdapter;
+    new (options: LokiJquerySyncAdapterOptions): LokiJquerySyncAdapter;
 
-    saveDatabase(name: any, data: any, callback?: (data: any, textStatus: string, jqXHR: XMLHttpRequest/*JQueryXHR*/) => any): void;
-
-    loadDatabase(name: any, callback?: (data: any, textStatus: string, jqXHR: XMLHttpRequest/*JQueryXHR*/) => any): void;
+    saveDatabase(name: string, data: any, callback?: (data: any, textStatus: string, xhr: XMLHttpRequest) => any): void;
 
+    loadDatabase(name: string, callback?: (data: any, textStatus: string, xhr: XMLHttpRequest) => any): void;
 }
-/* ==== END jquery-sync-adapter.js ==== */
 
 
+interface LokiJquerySyncAdapterOptions {
+    ajaxLib: { ajax(options: any): any; };
+    save: {
+        url: any;
+        type?: string; /*'GET', 'POST, 'DELETE', etc.*/
+        dataType?: string; /*'json', 'xml', etc.*/
+    };
+    load: {
+        url: any;
+        type?: string; /*'GET', 'POST, 'DELETE', etc.*/
+        dataType?: string; /*'json', 'xml', etc.*/
+    };
+}
+
+
+interface LokiJquerySyncAdapterError extends Error {
+    name: string; // "JquerySyncAdapterError"
+    message: any;
+
+    new (message: any): LokiJquerySyncAdapterError;
+}
+/* ======== END jquery-sync-adapter.js ======== */
+
+
+declare var LokiCryptedFileAdapterConstructor: {
+    new (): LokiCryptedFileAdapter;
+}
+
+declare module "lokiCryptedFileAdapter" {
+    export = LokiCryptedFileAdapterConstructor;
+}
+
+
+declare var LokiIndexedAdapterConstructor: {
+    new (filename: string): LokiIndexedAdapter;
+}
+
+declare module "loki-indexed-adapter" {
+    export = LokiIndexedAdapterConstructor;
+}
 
 
 declare var LokiConstructor: {
     new (filename: string, options?: LokiConfigureOptions): Loki;
+    LokiOps: LokiOps;
     Collection: LokiCollection<any>;
     KeyValueStore: LokiKeyValueStore<any, any>;
 }
 
-
 declare module "lokijs" {
     export = LokiConstructor;
 }
diff --git a/merge-stream/merge-stream-tests.ts b/merge-stream/merge-stream-tests.ts
index e0c744953..140013eb9 100644
--- a/merge-stream/merge-stream-tests.ts
+++ b/merge-stream/merge-stream-tests.ts
@@ -11,3 +11,9 @@ var merged = merge(stream1, stream2);
 
 var stream3 = new Stream();
 merged.add(stream3);
+
+var stream4 = new Stream();
+var stream5 = new Stream();
+merged.add([stream4, stream5]);
+
+merged.isEmpty();
diff --git a/merge-stream/merge-stream.d.ts b/merge-stream/merge-stream.d.ts
index 6dfffdb95..d2f8c756e 100644
--- a/merge-stream/merge-stream.d.ts
+++ b/merge-stream/merge-stream.d.ts
@@ -1,14 +1,15 @@
-// Type definitions for merge-stream
+// Type definitions for merge-stream v1.0.0
 // Project: https://github.com/grncdr/merge-stream
-// Definitions by: Keita Kagurazaka <https://github.com/k-kagurazaka>
-// Definitions: https://github.com/borisyankov/DefinitelyTyped
+// Definitions by: Keita Kagurazaka <https://github.com/k-kagurazaka>, Tom X. Tobin <http://tomxtobin.com/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
 /// <reference path="../node/node.d.ts"/>
 
 declare module "merge-stream" {
-
     interface IMergedStream extends NodeJS.ReadWriteStream {
-        add: (source: NodeJS.ReadableStream) => IMergedStream;
+        add(source: NodeJS.ReadableStream): IMergedStream;
+        add(source: NodeJS.ReadableStream[]): IMergedStream;
+        isEmpty(): boolean;
     }
 
     function merge<T extends NodeJS.ReadableStream>(...streams: T[]): IMergedStream;
diff --git a/microsoft-sdk-soap/microsoft-sdk-soap.d.ts b/microsoft-sdk-soap/microsoft-sdk-soap.d.ts
index 217710aac..c3100e69b 100644
--- a/microsoft-sdk-soap/microsoft-sdk-soap.d.ts
+++ b/microsoft-sdk-soap/microsoft-sdk-soap.d.ts
@@ -2657,22 +2657,22 @@ declare module Sdk.Mdq
 
     export interface IEntityMetadata
     {
-        ActivityTypeMask: any;
+        ActivityTypeMask: number;
         Attributes: IAttributeMetadata[];
         AutoCreateAccessTeams: any;
         AutoRouteToOwnerQueue: boolean;
-        CanBeInManyToMany: boolean;
-        CanBePrimaryEntityInRelationship: boolean;
-        CanBeRelatedEntityInRelationship: boolean;
-        CanCreateAttributes: boolean;
-        CanCreateCharts: boolean;
-        CanCreateForms: boolean;
-        CanCreateViews: boolean;
-        CanModifyAdditionalSettings: boolean;
+        CanBeInManyToMany: ManagedProperty<boolean>;
+        CanBePrimaryEntityInRelationship: ManagedProperty<boolean>;
+        CanBeRelatedEntityInRelationship: ManagedProperty<boolean>;
+        CanCreateAttributes: ManagedProperty<boolean>;
+        CanCreateCharts: ManagedProperty<boolean>;
+        CanCreateForms: ManagedProperty<boolean>;
+        CanCreateViews: ManagedProperty<boolean>;
+        CanModifyAdditionalSettings: ManagedProperty<boolean>;
         CanTriggerWorkflow: boolean;
-        Description: string;
-        DisplayCollectionName: string;
-        DisplayName: string;
+        Description: Label;
+        DisplayCollectionName: Label;
+        DisplayName: Label;
         IconLargeName: string;
         IconMediumName: string;
         IconSmallName: string;
@@ -2680,60 +2680,145 @@ declare module Sdk.Mdq
         IsActivity: boolean;
         IsActivityParty: boolean;
         IsAIRUpdated: boolean;
-        IsAuditEnabled: boolean;
+        IsAuditEnabled: ManagedProperty<boolean>;
         IsAvailableOffline: boolean;
         IsBusinessProcessEnabled: boolean;
         IsChildEntity: boolean;
-        IsConnectionsEnabled: boolean;
+        IsConnectionsEnabled: ManagedProperty<boolean>;
         IsCustomEntity: boolean;
-        IsCustomizable: boolean;
+        IsCustomizable: ManagedProperty<boolean>;
         IsDocumentManagementEnabled: boolean;
-        IsDuplicateDetectionEnabled: boolean;
+        IsDuplicateDetectionEnabled: ManagedProperty<boolean>;
         IsEnabledForCharts: boolean;
         IsImportable: boolean;
         IsIntersect: boolean;
-        IsMailMergeEnabled: boolean;
+        IsMailMergeEnabled: ManagedProperty<boolean>;
         IsManaged: boolean;
-        IsMappable: boolean;
+        IsMappable: ManagedProperty<boolean>;
         IsQuickCreateEnabled: boolean;
         IsReadingPaneEnabled: boolean;
         IsRenameable: boolean;
         IsValidForAdvancedFind: boolean;
-        IsValidForQueue: boolean;
-        IsVisibleInMobile: boolean;
+        IsValidForQueue: ManagedProperty<boolean>;
+        IsVisibleInMobile: ManagedProperty<boolean>;
         IsVisibleInMobileClient: boolean;
         LogicalName: string;
-        ManyToManyRelationships: any;
-        ManyToOneRelationships: any;
+        ManyToManyRelationships: ManyToManyRelationshipMetadata;
+        ManyToOneRelationships: OneToManyRelationshipMetadata;
         MetadataId: string;
         ObjectTypeCode: number;
-        OneToManyRelationships: any;
-        OwnershipType: string;
+        OneToManyRelationships: OneToManyRelationshipMetadata;
+        OwnershipType: "BusinessOwned" | "BusinessParented" | "None	OrganizationOwned" | "TeamOwned	UserOwned";
         PrimaryIdAttribute: string;
         PrimaryImageAttribute: string;
         PrimaryNameAttribute: string;
-        Privileges: any;
+        Privileges: SecurityPrivilegeMetadata[];
         RecurrenceBaseEntityLogicalName: string;
         ReportViewName: string;
         SchemaName: string;
     }
 
+    export interface SecurityPrivilegeMetadata
+    {
+        CanBeBasic: boolean;
+        CanBeDeep: boolean;
+        CanBeEntityReference: boolean;
+        CanBeGlobal: boolean;
+        CanBeLocal: boolean;
+        CanBeParentEntityReference: boolean;
+        ExtensionData: boolean;
+        Name: string;
+        PrivilegeId: string;
+        PrivilegeType: "Append" | "AppendTo" | "Assign" | "Create" | "Delete" | "None" | "Read" | "Share" | "Write";
+    }
+
+    export interface OneToManyRelationshipMetadata
+    {
+        AssociatedMenuConfiguration: AssociatedMenuConfiguration;
+        CascadeConfiguration: CascadeConfiguration;
+        HasChanged: any;
+        IntroducedVersion: any;
+        IsCustomizable: ManagedProperty<boolean>;
+        IsCustomRelationship: boolean;
+        IsHierarchical: any;
+        IsManaged: boolean;
+        IsValidForAdvancedFind: boolean;
+        MetadataId: string;
+        ReferencedAttribute: string;
+        ReferencedEntity: string;
+        ReferencingAttribute: string;
+        ReferencingEntity: string;
+        RelationshipType: string;
+        SchemaName: string;
+        SecurityTypes: any;
+    }
+
+    export interface CascadeConfiguration
+    {
+        Assign: CascadeType;
+        Delete: CascadeType;
+        ExtensionData: CascadeType;
+        Merge: CascadeType;
+        Reparent: CascadeType;
+        Share: CascadeType;
+        Unshare: CascadeType;
+    }
+
+    export type CascadeType = "Active" | "Cascade" | "NoCascade" | "UserOwned";
+
+    export interface ManyToManyRelationshipMetadata
+    {
+        Entity1AssociatedMenuConfiguration: AssociatedMenuConfiguration;
+        Entity1IntersectAttribute: string;
+        Entity1LogicalName: string;
+        Entity2AssociatedMenuConfiguration: AssociatedMenuConfiguration;
+        Entity2IntersectAttribute: string;
+        Entity2LogicalName: string;
+        HasChanged: boolean;
+        IntersectEntityName: string;
+        IntroducedVersion: any;
+        IsCustomizable: ManagedProperty<boolean>;
+        IsCustomRelationship: boolean;
+        IsManaged: boolean;
+        IsValidForAdvancedFind: boolean;
+        MetadataId: string;
+        RelationshipType: RelationshipType;
+        SchemaName: string;
+        SecurityTypes: SecurityType;
+    }
+
+    export interface AssociatedMenuConfiguration
+    {
+        Behavior: AssociatedMenuBehavior;
+        Group: AssociatedMenuGroup;
+        Label: Label;
+        Order: number;
+    }
+
+    export type AssociatedMenuBehavior = "DoNotDisplay" | "UseCollectionName" | "UseLabel";
+
+    export type AssociatedMenuGroup = "Details" | "Marketing" | "Sales" | "Service";
+
+    export type RelationshipType = "Default" | "ManyToManyRelationship" | "OneToManyRelationship";
+
+    export type SecurityType = "Append" | "Inheritance" | "None" | "ParentChild" | "Pointer";
+
     export interface IAttributeMetadata
     {
-        AttributeOf: any;
-        AttributeType: any;
-        AttributeTypeName: string;
+        AttributeOf: string;
+        AttributeType: "Customer" | "DateTime" | "Decimal" | "Double" | "EntityName" | "Integer" | "Lookup" | "ManagedProperty" | "Memo" | "Money" | "Owner" | "PartyList" | "Picklist" | "State" | "Status" | "Uniqueidentifier" | "Virtual"
+        AttributeTypeName: "BigIntType" | "BooleanType" | "CalendarRulesType" | "CustomerType" | "DateTimeType" | "DecimalType" | "DoubleType" | "EntityNameType" | "ImageType" | "IntegerType" | "LookupType" | "ManagedPropertyType" | "MemoType" | "MoneyType" | "OwnerType" | "PartyListType" | "PicklistType" | "StateType	StatusType" | "StringType" | "UniqueidentifierType" | "VirtualType";
         CalculationOf: any;
         CanBeSecuredForCreate: boolean;
         CanBeSecuredForRead: boolean;
         CanBeSecuredForUpdate: boolean;
-        CanModifyAdditionalSettings: boolean;
+        CanModifyAdditionalSettings: ManagedProperty<boolean>;
         ColumnNumber: number;
         DefaultFormValue: any;
         DefaultValue: any;
         DeprecatedVersion: any;
-        Description: string;
-        DisplayName: string;
+        Description: Label;
+        DisplayName: Label;
         EntityLogicalName: string;
         Format: any;
         FormatName: string;
@@ -2741,13 +2826,13 @@ declare module Sdk.Mdq
         IntroducedVersion: any;
         IsAuditEnabled: boolean;
         IsCustomAttribute: boolean;
-        IsCustomizable: boolean;
+        IsCustomizable: ManagedProperty<boolean>;
         IsManaged: boolean;
         IsPrimaryId: boolean;
         IsPrimaryName: boolean;
-        IsRenameable: boolean;
+        IsRenameable: ManagedProperty<boolean>;
         IsSecured: boolean;
-        IsValidForAdvancedFind: boolean;
+        IsValidForAdvancedFind: ManagedProperty<boolean>;
         IsValidForCreate: boolean;
         IsValidForRead: boolean;
         IsValidForUpdate: boolean;
@@ -2760,12 +2845,34 @@ declare module Sdk.Mdq
         OptionSet: any;
         Precision: any;
         PrecisionSource: any;
-        RequiredLevel: any;
+        RequiredLevel: ManagedProperty<string>;
         SchemaName: string;
         Targets: string[];
         YomiOf: any;
     }
 
+    export interface ManagedProperty<T>
+    {
+        CanBeChanged: boolean;
+        ManagedPropertyLogicalName: string;
+        Value: T;
+    }
+
+    export interface Label
+    {
+        LocalizedLabels: LocalizedLabel[];
+        UserLocalizedLabel: LocalizedLabel;
+    }
+
+    export interface LocalizedLabel
+    {
+        Label: string;
+        LangaugeCode: number;
+        MetadataId: string;
+        HasChanged: boolean;
+        IsManaged: boolean;
+    }
+
     module ValueEnums
     {
         export enum OwnershipType
@@ -2860,4 +2967,4 @@ declare module Sdk.Mdq
 }
 
 declare module Sdk.Mdq.ValueEnums
-{ }
+{ }
\ No newline at end of file
diff --git a/node/node.d.ts b/node/node.d.ts
index 0a1e1ddc5..2176af4ab 100644
--- a/node/node.d.ts
+++ b/node/node.d.ts
@@ -80,6 +80,7 @@ declare var SlowBuffer: {
 
 
 // Buffer class
+type BufferEncoding = "ascii" | "utf8" | "utf16le" | "ucs2" | "binary" | "hex";
 interface Buffer extends NodeBuffer {}
 
 /**
@@ -227,8 +228,8 @@ declare module NodeJS {
         removeListener(event: string, listener: Function): this;
         removeAllListeners(event?: string): this;
     }
-    
-    export interface MemoryUsage { 
+
+    export interface MemoryUsage {
         rss: number;
         heapTotal: number;
         heapUsed: number;
@@ -945,7 +946,7 @@ declare module "child_process" {
         stdin:  stream.Writable;
         stdout: stream.Readable;
         stderr: stream.Readable;
-        stdio: (stream.Readable|stream.Writable)[];
+        stdio: [stream.Writable, stream.Readable, stream.Readable];
         pid: number;
         kill(signal?: string): void;
         send(message: any, sendHandle?: any): void;
@@ -953,39 +954,66 @@ declare module "child_process" {
         unref(): void;
     }
 
-    export function spawn(command: string, args?: string[], options?: {
+    export interface SpawnOptions {
         cwd?: string;
-        stdio?: any;
-        custom?: any;
         env?: any;
+        stdio?: any;
         detached?: boolean;
-    }): ChildProcess;
-    export function exec(command: string, options: {
+        uid?: number;
+        gid?: number;
+        shell?: boolean | string;
+    }
+    export function spawn(command: string, args?: string[], options?: SpawnOptions): ChildProcess;
+
+    export interface ExecOptions {
         cwd?: string;
-        stdio?: any;
-        customFds?: any;
         env?: any;
-        encoding?: string;
+        shell?: string;
         timeout?: number;
         maxBuffer?: number;
         killSignal?: string;
-    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function exec(command: string, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function execFile(file: string,
-        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function execFile(file: string, args?: string[],
-        callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function execFile(file: string, args?: string[], options?: {
+        uid?: number;
+        gid?: number;
+    }
+    export interface ExecOptionsWithStringEncoding extends ExecOptions {
+        encoding: BufferEncoding;
+    }
+    export interface ExecOptionsWithBufferEncoding extends ExecOptions {
+        encoding: string; // specify `null`.
+    }
+    export function exec(command: string, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    export function exec(command: string, options: ExecOptionsWithStringEncoding, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    // usage. child_process.exec("tsc", {encoding: null as string}, (err, stdout, stderr) => {});
+    export function exec(command: string, options: ExecOptionsWithBufferEncoding, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function exec(command: string, options: ExecOptions, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+
+    export interface ExecFileOptions {
         cwd?: string;
-        stdio?: any;
-        customFds?: any;
         env?: any;
-        encoding?: string;
         timeout?: number;
         maxBuffer?: number;
         killSignal?: string;
-    }, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
-    export function fork(modulePath: string, args?: string[], options?: {
+        uid?: number;
+        gid?: number;
+    }
+    export interface ExecFileOptionsWithStringEncoding extends ExecFileOptions {
+        encoding: BufferEncoding;
+    }
+    export interface ExecFileOptionsWithBufferEncoding extends ExecFileOptions {
+        encoding: string; // specify `null`.
+    }
+    export function execFile(file: string, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    export function execFile(file: string, options?: ExecFileOptionsWithStringEncoding, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    // usage. child_process.execFile("file.sh", {encoding: null as string}, (err, stdout, stderr) => {});
+    export function execFile(file: string, options?: ExecFileOptionsWithBufferEncoding, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, options?: ExecFileOptions, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[], callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[], options?: ExecFileOptionsWithStringEncoding, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+    // usage. child_process.execFile("file.sh", ["foo"], {encoding: null as string}, (err, stdout, stderr) => {});
+    export function execFile(file: string, args?: string[], options?: ExecFileOptionsWithBufferEncoding, callback?: (error: Error, stdout: Buffer, stderr: Buffer) =>void ): ChildProcess;
+    export function execFile(file: string, args?: string[], options?: ExecFileOptions, callback?: (error: Error, stdout: string, stderr: string) =>void ): ChildProcess;
+
+    export interface ForkOptions {
         cwd?: string;
         env?: any;
         execPath?: string;
@@ -993,8 +1021,10 @@ declare module "child_process" {
         silent?: boolean;
         uid?: number;
         gid?: number;
-    }): ChildProcess;
-    export function spawnSync(command: string, args?: string[], options?: {
+    }
+    export function fork(modulePath: string, args?: string[], options?: ForkOptions): ChildProcess;
+
+    export interface SpawnSyncOptions {
         cwd?: string;
         input?: string | Buffer;
         stdio?: any;
@@ -1002,42 +1032,83 @@ declare module "child_process" {
         uid?: number;
         gid?: number;
         timeout?: number;
-        maxBuffer?: number;
         killSignal?: string;
+        maxBuffer?: number;
         encoding?: string;
-    }): {
+        shell?: boolean | string;
+    }
+    export interface SpawnSyncOptionsWithStringEncoding extends SpawnSyncOptions {
+        encoding: BufferEncoding;
+    }
+    export interface SpawnSyncOptionsWithBufferEncoding extends SpawnSyncOptions {
+        encoding: string; // specify `null`.
+    }
+    export interface SpawnSyncReturns<T> {
         pid: number;
         output: string[];
-        stdout: string | Buffer;
-        stderr: string | Buffer;
+        stdout: T;
+        stderr: T;
         status: number;
         signal: string;
         error: Error;
-    };
-    export function execSync(command: string, options?: {
+    }
+    export function spawnSync(command: string): SpawnSyncReturns<Buffer>;
+    export function spawnSync(command: string, options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+    export function spawnSync(command: string, options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
+    export function spawnSync(command: string, options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
+    export function spawnSync(command: string, args?: string[], options?: SpawnSyncOptionsWithStringEncoding): SpawnSyncReturns<string>;
+    export function spawnSync(command: string, args?: string[], options?: SpawnSyncOptionsWithBufferEncoding): SpawnSyncReturns<Buffer>;
+    export function spawnSync(command: string, args?: string[], options?: SpawnSyncOptions): SpawnSyncReturns<Buffer>;
+
+    export interface ExecSyncOptions {
         cwd?: string;
-        input?: string|Buffer;
+        input?: string | Buffer;
+        stdio?: any;
+        env?: any;
+        shell?: string;
+        uid?: number;
+        gid?: number;
+        timeout?: number;
+        killSignal?: string;
+        maxBuffer?: number;
+        encoding?: string;
+    }
+    export interface ExecSyncOptionsWithStringEncoding extends ExecSyncOptions {
+        encoding: BufferEncoding;
+    }
+    export interface ExecSyncOptionsWithBufferEncoding extends ExecSyncOptions {
+        encoding: string; // specify `null`.
+    }
+    export function execSync(command: string): Buffer;
+    export function execSync(command: string, options?: ExecSyncOptionsWithStringEncoding): string;
+    export function execSync(command: string, options?: ExecSyncOptionsWithBufferEncoding): Buffer;
+    export function execSync(command: string, options?: ExecSyncOptions): Buffer;
+
+    export interface ExecFileSyncOptions {
+        cwd?: string;
+        input?: string | Buffer;
         stdio?: any;
         env?: any;
         uid?: number;
         gid?: number;
         timeout?: number;
-        maxBuffer?: number;
         killSignal?: string;
-        encoding?: string;
-    }): string | Buffer;
-    export function execFileSync(command: string, args?: string[], options?: {
-        cwd?: string;
-        input?: string|Buffer;
-        stdio?: any;
-        env?: any;
-        uid?: number;
-        gid?: number;
-        timeout?: number;
         maxBuffer?: number;
-        killSignal?: string;
         encoding?: string;
-    }): string | Buffer;
+    }
+    export interface ExecFileSyncOptionsWithStringEncoding extends ExecFileSyncOptions {
+        encoding: BufferEncoding;
+    }
+    export interface ExecFileSyncOptionsWithBufferEncoding extends ExecFileSyncOptions {
+        encoding: string; // specify `null`.
+    }
+    export function execFileSync(command: string): Buffer;
+    export function execFileSync(command: string, options?: ExecFileSyncOptionsWithStringEncoding): string;
+    export function execFileSync(command: string, options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    export function execFileSync(command: string, options?: ExecFileSyncOptions): Buffer;
+    export function execFileSync(command: string, args?: string[], options?: ExecFileSyncOptionsWithStringEncoding): string;
+    export function execFileSync(command: string, args?: string[], options?: ExecFileSyncOptionsWithBufferEncoding): Buffer;
+    export function execFileSync(command: string, args?: string[], options?: ExecFileSyncOptions): Buffer;
 }
 
 declare module "url" {
diff --git a/pegjs/pegjs.d.ts b/pegjs/pegjs.d.ts
index 00f4c7316..e740177b5 100644
--- a/pegjs/pegjs.d.ts
+++ b/pegjs/pegjs.d.ts
@@ -1,5 +1,5 @@
 // Type definitions for PEG.js
-// Project: http://pegjs.majda.cz/
+// Project: http://pegjs.org/
 // Definitions by: vvakame <https://github.com/vvakame>, Tobias Kahlert <https://github.com/SrTobi>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
diff --git a/phonegap-nfc/phonegap-nfc-tests.ts b/phonegap-nfc/phonegap-nfc-tests.ts
new file mode 100644
index 000000000..ddaabebce
--- /dev/null
+++ b/phonegap-nfc/phonegap-nfc-tests.ts
@@ -0,0 +1,80 @@
+/// <reference path="phonegap-nfc.d.ts"/>
+
+import nfc = require('nfc');
+import ndef = require('ndef');
+import NdefRecord = PhoneGapNfc.NdefRecord;
+
+nfc.addTagDiscoveredListener(() => {});
+nfc.addTagDiscoveredListener(() => {},() => {}, () => {});
+
+nfc.addMimeTypeListener('text/json',() => {});
+nfc.addMimeTypeListener('text/json',() => {},() => {}, () => {});
+
+nfc.addNdefListener(() => {});
+nfc.addNdefListener(() => {}, () => {},() => {});
+
+nfc.addNdefFormatableListener(() => {});
+nfc.addNdefFormatableListener(() => {}, () => {}, () => {});
+
+nfc.write([],() => {}, () => {});
+
+nfc.makeReadOnly();
+nfc.makeReadOnly(() => {}, () => {});
+
+nfc.share([]);
+nfc.share([],() => {}, () => {});
+
+nfc.unshare();
+nfc.unshare(() => {}, () => {});
+
+nfc.handover('uri',() => {}, () => {});
+nfc.handover(['uri'],() => {}, () => {});
+nfc.handover('uri');
+nfc.handover(['uri']);
+
+nfc.stopHandover();
+nfc.stopHandover(() => {}, () => {});
+
+nfc.erase();
+nfc.erase(() => {}, () => {});
+
+nfc.enabled();
+nfc.enabled(() => {}, () => {});
+
+nfc.removeTagDiscoveredListener(() => {});
+nfc.removeTagDiscoveredListener(() => {},() => {},() => {});
+
+nfc.removeMimeTypeListener('text/json',() => {});
+nfc.removeMimeTypeListener('text/json',() => {},() => {},() => {});
+
+nfc.removeNdefListener(() => {});
+nfc.removeNdefListener(() => {},() => {},() => {});
+
+nfc.showSettings();
+nfc.showSettings(() => {},() => {});
+
+let record:NdefRecord = ndef.record(0x01,[0x0F],[0x0C],[0xFF]);
+
+record = ndef.textRecord('textRecord','fr',[24,78]);
+
+record = ndef.uriRecord('uriRecord',[24,78]);
+
+record = ndef.absoluteUriRecord('uriRecord',[88,142],[24,78]);
+
+record = ndef.mimeMediaRecord('text/json',[88,142],[24,78]);
+
+record = ndef.smartPoster([],[88,142]);
+
+record = ndef.emptyRecord();
+
+record = ndef.androidApplicationRecord('fr.redfroggy.phonegap');
+
+let bytes:Array<number> = ndef.encodeMessage([]);
+
+let records:Array<NdefRecord> = ndef.decodeMessage(bytes);
+
+let obj:any = ndef.decodeTnf(bytes[0]);
+
+let tnfByte:number = ndef.encodeTnf(bytes[0],bytes[1],bytes[2],bytes[3],bytes[4],bytes[5]);
+
+let tnfString:string = ndef.tnfToString(tnfByte);
diff --git a/phonegap-nfc/phonegap-nfc.d.ts b/phonegap-nfc/phonegap-nfc.d.ts
new file mode 100644
index 000000000..1a6c7bfd8
--- /dev/null
+++ b/phonegap-nfc/phonegap-nfc.d.ts
@@ -0,0 +1,460 @@
+// Type definitions for Phonegap NFC Plugin
+// Project: https://github.com/chariotsolutions/phonegap-nfc
+// Definitions by: Michael Desigaud <https://github.com/michaeldesigaud>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+interface Document {
+    addEventListener(type: 'deviceready', listener: (ev: Event) => any, useCapture?: boolean): void;
+}
+
+declare module PhoneGapNfc {
+
+    /**
+     * Global object NFC.
+     */
+    interface Window {
+        nfc: Nfc;
+        ndef: Ndef;
+        util:Util;
+        fireNfcTagEvent(event:TagEvent, tagAsJson:string):void;
+    }
+
+    interface Tag {
+        id:Array<number>;
+        techTypes:Array<string>;
+        type:string;
+        date:string;
+    }
+
+    interface NdefRecord {
+        /**
+         * 3-bit TNF (Type Name Format) - use one of the TNF_* constants
+         */
+        tnf:number;
+        /**
+         * byte array, containing zero to 255 bytes, must not be null
+         */
+            type:Array<number>;
+        /**
+         * byte array, containing zero to 255 bytes, must not be null
+         */
+        id:Array<number>;
+        /**
+         * byte array, containing zero to (2 ** 32 - 1) bytes, must not be null
+         */
+        payload:Array<number>;
+    }
+
+    interface NdefTag extends Tag {
+        canMakeReadOnly:boolean;
+        isWritable:boolean;
+        maxSize:number;
+        records:Array<NdefRecord>;
+    }
+
+    interface TagEvent extends Event {
+        tag:Tag;
+    }
+
+    interface NdefTagEvent extends TagEvent {
+        tag:NdefTag;
+    }
+
+    interface UriHelper {
+        /**
+         * URI identifier codes from URI Record Type Definition NFCForum-TS-RTD_URI_1.0 2006-07-24
+         * index in array matches code in the spec
+         */
+        protocols:Array<string>;
+
+        /**
+         * Decode a URI payload bytes
+         * @param data
+         */
+        decodePayload(data:any):string;
+
+        /**
+         * shorten a URI with standard prefix
+         * @param uri
+         */
+        encodePayload(uri:string):Array<number>;
+    }
+
+    interface TextHelper {
+
+        /**
+         * Decode a URI payload bytes
+         * @param data
+         */
+        decodePayload(data:any):string;
+
+        /**
+         * Encode text payload
+         * @param text
+         * @param lang
+         * @param encoding
+         */
+        encodePayload(text:string, lang:string, encoding:string):Array<number>;
+    }
+
+    /**
+     * The Ndef object.
+     */
+    interface Ndef {
+
+        TNF_EMPTY:number;
+        TNF_WELL_KNOWN: number;
+        TNF_MIME_MEDIA: number;
+        TNF_ABSOLUTE_URI: number;
+        TNF_EXTERNAL_TYPE: number;
+        TNF_UNKNOWN: number;
+        TNF_UNCHANGED: number;
+        TNF_RESERVED: number;
+
+        RTD_TEXT: Array<number>; // "T"
+        RTD_URI: Array<number>; // "U"
+        RTD_SMART_POSTER: Array<number>; // "Sp"
+        RTD_ALTERNATIVE_CARRIER: Array<number>; // "ac"
+        RTD_HANDOVER_CARRIER: Array<number>; // "Hc"
+        RTD_HANDOVER_REQUEST: Array<number>; // "Hr"
+        RTD_HANDOVER_SELECT: Array<number>; // "Hs"
+
+        uriHelper:UriHelper;
+        textHelper:TextHelper;
+        /**
+         * Creates a JSON representation of a NdefRecord.
+         *
+         * @param tnf 3-bit TNF (Type Name Format) - use one of the TNF_* constants
+         * @param type array, containing zero to 255 bytes, must not be null
+         * @param id byte array, containing zero to 255 bytes, must not be null
+         * @param payload byte array, containing zero to (2 ** 32 - 1) bytes, must not be null
+         *
+         * @return NdefRecord
+         *
+         * @see Ndef.textRecord, Ndef.uriRecord and Ndef.mimeMediaRecord for examples
+         */
+        record(tnf:number, type:Array<number>, id:Array<number>, payload:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates an NdefRecord containing plain text.
+         *
+         * @param text String of text to encode
+         * @paramlanguageCode ISO/IANA language code. Examples: “fi”, “en-US”, “fr- CA”, “jp”. (optional)
+         * @param id byte[] (optional)
+         *
+         * @return NdefRecord
+         */
+        textRecord(text:string, languageCode:string, id:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates a NdefRecord containing a URI.
+         *
+         * @param uri String
+         * @param id byte[] (optional)
+         *
+         * @return NdefRecord
+         */
+        uriRecord(uri:string, id:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates a NdefRecord containing an absolute URI.
+         *
+         * An Absolute URI record means the URI describes the payload of the record.
+         *
+         * For example a SOAP message could use "http://schemas.xmlsoap.org/soap/envelope/"
+         * as the type and XML content for the payload.
+         *
+         * Absolute URI can also be used to write LaunchApp records for Windows.
+         *
+         * See 2.4.2 Payload Type of the NDEF Specification
+         * http://www.nfc-forum.org/specs/spec_list#ndefts
+         *
+         * Note that by default, Android will open the URI defined in the type
+         * field of an Absolute URI record (TNF=3) and ignore the payload.
+         * BlackBerry and Windows do not open the browser for TNF=3.
+         *
+         * To write a URI as the payload use ndef.uriRecord(uri)
+         *
+         * @param uri String
+         * @param payload byte[] or String
+         * @param id byte[] (optional)
+         *
+         * @return NdefRecord
+         */
+        absoluteUriRecord(uri:string, payload:Array<number>, id:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates a NdefRecordcontaining an mimeMediaRecord.
+         *
+         * @param mimeType String
+         * @param payload byte[]
+         * @param id byte[] (optional)
+         */
+        mimeMediaRecord(mimeType:string, payload:Array<number>, id:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates an NDEF record containing an Smart Poster.
+         *
+         * @param ndefRecords array of NdefRecord
+         * @param id byte[] (optional)
+         *
+         * @return NdefRecord
+         */
+        smartPoster(ndefRecords:Array<NdefRecord>, id:Array<number>):NdefRecord;
+
+        /**
+         * Helper that creates an empty NdefRecord.
+         *
+         */
+        emptyRecord():NdefRecord;
+
+        /**
+         * Helper that creates an Android Application Record (AAR).
+         * http://developer.android.com/guide/topics/connectivity/nfc/nfc.html#aar
+         * @param packageName android package name
+         *
+         */
+        androidApplicationRecord(packageName:string):NdefRecord;
+
+        /**
+         * Encodes an NDEF Message into bytes that can be written to a NFC tag.
+         *
+         * @param ndefRecords an Array of NdefRecord
+         *
+         * @return Array<number>
+         *
+         * @see NFC Data Exchange Format (NDEF) http://www.nfc-forum.org/specs/spec_list/
+         */
+        encodeMessage(ndefRecords:Array<NdefRecord>):Array<number>;
+
+        /**
+         * Decodes an array bytes into an NDEF Message
+         *
+         * @param bytes Array<number> read from a NFC tag
+         *
+         * @return array of NdefRecord
+         *
+         * @see NFC Data Exchange Format (NDEF) http://www.nfc-forum.org/specs/spec_list/
+         */
+        decodeMessage(bytes:Array<number>):Array<NdefRecord>;
+
+        /**
+         * Decode the bit flags from a TNF Byte.
+         *
+         * @return object with decoded data
+         *
+         *  See NFC Data Exchange Format (NDEF) Specification Section 3.2 RecordLayout
+         */
+        decodeTnf(tnf_byte:number):any;
+
+        /**
+         * Encode NDEF bit flags into a TNF Byte.
+         *
+         * @return tnf byte
+         *
+         *  See NFC Data Exchange Format (NDEF) Specification Section 3.2 RecordLayout
+         */
+        encodeTnf(mb:number, me:number, cf:number, sr:number, il:number, tnf:number):number;
+
+        /**
+         * Convert TNF to String for user friendly display
+         *
+         *@param tnf tnf byte
+         */
+        tnfToString(tnf:number):string;
+    }
+
+    interface Util {
+        /**
+         * Convert bytes to string
+         * @param bytes
+         */
+        bytesToString(bytes:Array<number>):string;
+
+        /**
+         * Convert string to bytes
+         * @param string
+         */
+        stringToBytes(string:string):Array<number>;
+
+        /**
+         * Convert bytes to hexadecimal string
+         * @param bytes
+         */
+        bytesToHexString(bytes:Array<number>):string;
+    }
+
+    /**
+     * The Nfc object.
+     */
+    interface Nfc extends Util {
+        /**
+         * Function nfc.addTagDiscoveredListener registers the callback for tag events.
+         * This event occurs when any tag is detected by the phone
+         * @param callback The callback that is called when a tag is detected.
+         * @param win The callback that is called when the listener is added.
+         * @param fail The callback that is called if there was an error.
+         */
+        addTagDiscoveredListener(callback:(event:TagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.addMimeTypeListener registers the callback for ndef-mime events.
+         * A ndef-mime event occurs when a Ndef.TNF_MIME_MEDIA tag is read and matches the specified MIME type.
+         * This function can be called multiple times to register different MIME types. You should use the same handler for all MIME messages.
+         * @param mimeType The MIME type to filter for messages.
+         * @param callback The callback that is called when an NDEF tag matching the MIME type is read.
+         * @param win The callback that is called when the listener is added.
+         * @param fail The callback that is called if there was an error.
+         */
+        addMimeTypeListener(mimeType:string, callback:() => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.addNdefListener registers the callback for ndef events.
+         * A ndef event is fired when a NDEF tag is read.
+         * For BlackBerry 10, you must configure the type of tags your application will read with an invoke-target in config.xml.
+         * On Android registered mimeTypeListeners takes precedence over this more generic NDEF listener.
+         * @param callback The callback that is called when an NDEF tag is read.
+         * @param win The callback that is called when the listener is added.
+         * @param fail The callback that is called if there was an error.
+         */
+        addNdefListener(callback:(event:NdefTagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.addNdefFormatableListener registers the callback for ndef-formatable events.
+         * A ndef-formatable event occurs when a tag is read that can be NDEF formatted.
+         * This is not fired for tags that are already formatted as NDEF.
+         * The ndef-formatable event will not contain an NdefMessage.
+         * @param callback The callback that is called when NDEF formatable tag is read.
+         * @param win The callback that is called when the listener is added.
+         * @param fail The callback that is called if there was an error.
+         */
+        addNdefFormatableListener(callback:(event:NdefTagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.write writes an NdefMessage to a NFC tag.
+         * On Android this method must be called from within an NDEF TagEvent Handler.
+         * On Windows this method may be called from within the NDEF TagEvent Handler.
+         * On Windows Phone 8.1 this method should be called outside the NDEF TagEvent Handler,
+         * otherwise Windows tries to read the tag contents as you are writing to the tag.
+         * @param ndefMessage An array of NDEF Records.
+         * @param win The callback that is called when the tag is written.
+         * @param fail The callback that is called if there was an error.
+         */
+        write(ndefMessage:Array<NdefRecord>, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.makeReadOnly make a NFC tag read only.
+         * Warning this is permanent and can not be undone.
+         * On Android this method must be called from within an NDEF TagEvent Handler.
+         * @param win The callback that is called when the tag is locked.
+         * @param fail The callback that is called if there was an error.
+         */
+        makeReadOnly(win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.share writes an NdefMessage via peer-to-peer.
+         * This should appear as an NFC tag to another device.
+         * @param ndefMessage An array of NDEF Records.
+         * @param win The callback that is called when the message is pushed.
+         * @param fail The callback that is called if there was an error.
+         */
+        share(ndefMessage:Array<NdefRecord>, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.unshare stops sharing data via peer-to-peer.
+         * @param win The callback that is called when sharing stops.
+         * @param fail The callback that is called if there was an error.
+         */
+        unshare(win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.handover shares files to a NFC peer using handover. Files are sent by specifying a file:// or context:// URI or a list of URIs.
+         * The file transfer is initiated with NFC but the transfer is completed with over Bluetooth or WiFi which is handled by a NFC handover request.
+         * The Android code is responsible for building the handover NFC Message.
+         * This is Android only, but it should be possible to add implementations for other platforms.
+         * @param uris A URI as a String, or an array of URIs.
+         * @param win The callback that is called when the message is pushed.
+         * @param fail The callback that is called if there was an error.
+         */
+        handover(uris:string|Array<string>, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.stopHandover stops sharing data via peer-to-peer.
+         * @param win The callback that is called when sharing stops.
+         * @param fail The callback that is called if there was an error.
+         */
+        stopHandover(win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.erase erases a tag by writing an empty message.
+         * Will format unformatted tags before writing.
+         * This method must be called from within an NDEF TagEvent Handler.
+         * @param win The callback that is called when sharing stops.
+         * @param fail The callback that is called if there was an error.
+         */
+        erase(win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function nfc.enabled explicitly checks to see if the phone has NFC and if NFC is enabled.
+         * If everything is OK, the success callback is called.
+         * If there is a problem, the failure callback will be called with a reason code.
+         * The reason will be NO_NFC if the device doesn't support NFC and NFC_DISABLED if the user has disabled NFC.
+         * Note: that on Android the NFC status is checked before every API call NO_NFC or NFC_DISABLED can be returned in any failure function.
+         * Windows will return NO_NFC_OR_NFC_DISABLED when NFC is not present or disabled.
+         * If the user disabled NFC after the application started, Windows may return NFC_DISABLED.
+         * Windows checks the NFC status before most API calls, but there are some cases when the NFC state can not be determined.
+         * @param win The callback that is called when NFC is enabled.
+         * @param fail The callback that is called when NFC is disabled or missing.
+         */
+        enabled(win?:() => void, fail?:() => void):void;
+
+        /**
+         * Removes the previously registered event listener added via nfc.addTagDiscoveredListener
+         * @param callback The previously registered callback.
+         * @param win The callback that is called when the listener is successfully removed.
+         * @param fail The callback that is called if there was an error during removal.
+         */
+        removeTagDiscoveredListener(callback:(event:TagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Removes the previously registered event listener added via nfc.addMimeTypeListener
+         * @param mimeType The MIME type to filter for messages.
+         * @param callback The previously registered callback.
+         * @param win The callback that is called when the listener is successfully removed.
+         * @param fail The callback that is called if there was an error during removal.
+         */
+        removeMimeTypeListener(mimeType:string, callback:(event:TagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Removes the previously registered event listener for NDEF tags added via nfc.addNdefListener.
+         * @param callback The previously registered callback.
+         * @param win The callback that is called when the listener is successfully removed.
+         * @param fail The callback that is called if there was an error during removal.
+         */
+        removeNdefListener(callback:(event:TagEvent) => void, win?:() => void, fail?:() => void):void;
+
+        /**
+         * Function showSettings opens the NFC settings for the operating system.
+         * @param win Success callback function
+         * @param fail Error callback function, invoked when error occurs.
+         */
+        showSettings(win?:() => void, fail?:() => void):void;
+    }
+}
+
+declare module 'nfc' {
+    var nfc:PhoneGapNfc.Nfc;
+    export = nfc;
+}
+
+declare module 'ndef' {
+    var ndef:PhoneGapNfc.Ndef;
+    export = ndef;
+}
+
+declare module 'util' {
+    var util:PhoneGapNfc.Util;
+    export = util;
+}
+
+
diff --git a/react-dnd/react-dnd-tests.ts b/react-dnd/react-dnd-tests.ts
index 2c92b7b33..5be7832d5 100644
--- a/react-dnd/react-dnd-tests.ts
+++ b/react-dnd/react-dnd-tests.ts
@@ -262,7 +262,7 @@ module Board {
         };
 
         render() {
-            var squares: React.DOMElement<React.HTMLAttributes>[] = [];
+            var squares: React.ReactHTMLElement<HTMLDivElement>[] = [];
             for (let i = 0; i < 64; i++) {
                 squares.push(this._renderSquare(i));
             }
diff --git a/react-dropzone/react-dropzone.d.ts b/react-dropzone/react-dropzone.d.ts
index 0bd3e472b..7562a413e 100644
--- a/react-dropzone/react-dropzone.d.ts
+++ b/react-dropzone/react-dropzone.d.ts
@@ -5,33 +5,43 @@
 
 ///<reference path='../react/react.d.ts' />
 
-declare module "react-dropzone" {
-
-  import * as React from 'react';
-
-  namespace reactDropzone {
-
+declare module ReactDropzone {
+    import React = __React;
     interface DropzoneProps {
-      onDrop?: Function;
-      onDropAccepted?: Function;
-      onDropRejected?: Function;
-      onDragEnter?: Function;
-      onDragLeave?: Function;
-      style?: Object;
-      activeStyle?: Object;
-      className?: string;
-      activeClassName?: string;
-      rejectClassName?: string;
-      disableClick?: boolean;
-      multiple?: boolean;
-      accept?: string;
+        onDrop?: Function;
+        onDropAccepted?: Function;
+        onDropRejected?: Function;
+        onDragEnter?: Function;
+        onDragLeave?: Function;
+        style?: Object;
+        activeStyle?: Object;
+        className?: string;
+        activeClassName?: string;
+        rejectClassName?: string;
+        /**
+        * Clicking the <Dropzone> brings up the browser file picker. To disable, set to true.
+        */
+        disableClick?: boolean;
+        /**
+        * To accept only a single file, set this to false.
+        */
+        multiple?: boolean;
+        /**
+        * Filters the file types that are valid. It should have a valid MIME type according to input element, for example:
+        * application/pdf
+        * image/*
+        * audio/aiff,audio/midi
+        */
+        accept?: string;
     }
 
     export class Dropzone extends React.Component<DropzoneProps, {}> {
     }
 
-  }
+}
 
-  export = reactDropzone.Dropzone;
+declare module "react-dropzone" {
+    const Dropzone: typeof ReactDropzone.Dropzone;
+    export = Dropzone;
 }
 
diff --git a/react-holder/react-holder.d.ts b/react-holder/react-holder.d.ts
index f130239ad..b29cd0893 100644
--- a/react-holder/react-holder.d.ts
+++ b/react-holder/react-holder.d.ts
@@ -9,7 +9,7 @@ declare module "react-holder" {
 
   import React = __React;
 
-  interface ReactHolderProp extends React.HTMLProps<ReactHolder> {
+  interface ReactHolderProp extends React.HTMLAttributes {
     width: string | number;
     height: string | number;
     updateOnResize: boolean;
diff --git a/react-input-calendar/react-input-calendar.d.ts b/react-input-calendar/react-input-calendar.d.ts
index ec539382f..14b877c8d 100644
--- a/react-input-calendar/react-input-calendar.d.ts
+++ b/react-input-calendar/react-input-calendar.d.ts
@@ -76,7 +76,6 @@ declare module reactInputCalendar {
     }
     interface ReactInputCalendarState { }
     export class ReactInputCalendar extends __React.Component<ReactInputCalendarProps, ReactInputCalendarState> {
-        render(): __React.DOMElement<any>;
     }
 }
 declare var ReactInputCalendar: typeof reactInputCalendar.ReactInputCalendar
diff --git a/react-redux/react-redux-tests.tsx b/react-redux/react-redux-tests.tsx
index 9ba06ac21..2ffb30169 100644
--- a/react-redux/react-redux-tests.tsx
+++ b/react-redux/react-redux-tests.tsx
@@ -94,6 +94,7 @@ interface TodoProps {
 }
 interface DispatchProps {
     addTodo(userId: number, text: string): void;
+    action: Function;
 }
 declare var actionCreators: () => {
     action: Function;
@@ -275,14 +276,6 @@ class NonComponent {}
 // this doesn't compile
 //connect()(NonComponent);
 
-// connect()(SomeClass) has the same constructor as SomeClass itself
-class SomeClass extends Component<any, any> {
-    constructor(public foo: string) { super() }
-    public bar: number;
-}
-let bar: number = new (connect()(SomeClass))("foo").bar;
-
-
 // stateless functions
 interface HelloMessageProps { name: string; }
 function HelloMessage(props: HelloMessageProps) {
diff --git a/react-redux/react-redux.d.ts b/react-redux/react-redux.d.ts
index 9c46fd10c..9bb8f7d82 100644
--- a/react-redux/react-redux.d.ts
+++ b/react-redux/react-redux.d.ts
@@ -7,39 +7,75 @@
 /// <reference path="../redux/redux.d.ts" />
 
 declare module "react-redux" {
-  import { ComponentClass, Component, StatelessComponent } from 'react';
+  import { ComponentClass, Component, StatelessComponent, Props, ReactNode } from 'react';
   import { Store, Dispatch, ActionCreator } from 'redux';
 
-  export interface ComponentConstructDecorator<P> {
-    <TComponentConstruct extends (ComponentClass<P>|StatelessComponent<P>)>(component: TComponentConstruct): TComponentConstruct
+  interface ComponentDecorator<TOriginalProps extends Props<any>, TOwnProps extends Props<any>> {
+    (component: ComponentClass<TOriginalProps>): ComponentClass<TOwnProps>;
+  }
+
+  /**
+   * Decorator that infers the type from the original component
+   *
+   * Can't use the above decorator because it would default the type to {}
+   */
+  export interface InferableComponentDecorator {
+    <P, TComponentConstruct extends (ComponentClass<P>|StatelessComponent<P>)>(component: TComponentConstruct): TComponentConstruct;
   }
 
   /**
    * Connects a React component to a Redux store.
+   *
+   * - Without arguments, just wraps the component, without changing the behavior / props
+   *
+   * - If 2 params are passed (3rd param, mergeProps, is skipped), default behavior
+   * is to override ownProps (as stated in the docs), so what remains is everything that's
+   * not a state or dispatch prop
+   *
+   * - When 3rd param is passed, we don't know if ownProps propagate and whether they
+   * should be valid component props, because it depends on mergeProps implementation.
+   * As such, it is the user's responsibility to extend ownProps interface from state or
+   * dispatch props or both when applicable
+   *
    * @param mapStateToProps
    * @param mapDispatchToProps
    * @param mergeProps
    * @param options
-     */
-  export function connect<P>(mapStateToProps?: MapStateToProps,
-                             mapDispatchToProps?: MapDispatchToPropsFunction|MapDispatchToPropsObject,
-                             mergeProps?: MergeProps,
-                             options?: Options): ComponentConstructDecorator<P>;
+   */
+  export function connect(): InferableComponentDecorator;
+  export function connect<
+    TStateProps extends Props<any>,
+    TDispatchProps extends Props<any>,
+    TOwnProps extends Props<any>
+  >(
+    mapStateToProps: MapStateToProps<TStateProps, TOwnProps>,
+    mapDispatchToProps?: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>|MapDispatchToPropsObject
+  ): ComponentDecorator<TStateProps & TDispatchProps, TOwnProps>;
+  export function connect<
+    TStateProps extends Props<any>,
+    TDispatchProps extends Props<any>,
+    TOwnProps extends Props<any>
+  >(
+    mapStateToProps: MapStateToProps<TStateProps, TOwnProps>,
+    mapDispatchToProps: MapDispatchToPropsFunction<TDispatchProps, TOwnProps>|MapDispatchToPropsObject,
+    mergeProps: MergeProps<TStateProps, TDispatchProps, TOwnProps>,
+    options?: Options
+  ): ComponentDecorator<TStateProps & TDispatchProps, TOwnProps>;
 
-  interface MapStateToProps {
-    (state: any, ownProps?: any): any;
+  interface MapStateToProps<TStateProps, TOwnProps> {
+    (state: any, ownProps?: TOwnProps): TStateProps;
   }
 
-  interface MapDispatchToPropsFunction {
-    (dispatch: Dispatch, ownProps?: any): any;
+  interface MapDispatchToPropsFunction<TDispatchProps, TOwnProps> {
+    (dispatch: Dispatch, ownProps?: TOwnProps): TDispatchProps;
   }
 
   interface MapDispatchToPropsObject {
     [name: string]: ActionCreator;
   }
 
-  interface MergeProps {
-    (stateProps: any, dispatchProps: any, ownProps: any): any;
+  interface MergeProps<TStateProps, TDispatchProps, TOwnProps> {
+    (stateProps: TStateProps, dispatchProps: TDispatchProps, ownProps: TOwnProps): TStateProps & TDispatchProps;
   }
 
   interface Options {
@@ -53,16 +89,16 @@ declare module "react-redux" {
     pure: boolean;
   }
 
-  export interface Property {
+  export interface ProviderProps extends Props<Provider> {
     /**
      * The single Redux store in your application.
      */
     store?: Store;
-    children?: Function;
+    children?: ReactNode;
   }
 
   /**
    * Makes the Redux store available to the connect() calls in the component hierarchy below.
    */
-  export class Provider extends Component<Property, {}> { }
+  export class Provider extends Component<ProviderProps, {}> { }
 }
diff --git a/react-router/react-router.d.ts b/react-router/react-router.d.ts
index e87622e9b..e510b7406 100644
--- a/react-router/react-router.d.ts
+++ b/react-router/react-router.d.ts
@@ -395,6 +395,14 @@ declare module "react-router/lib/match" {
 
 }
 
+declare module "react-router/lib/useRouterHistory" {
+    interface CreateRouterHistory {
+        (options?: HistoryModule.HistoryOptions): HistoryModule.History & HistoryModule.HistoryQueries;
+    }
+
+    export default function useRouterHistory<T>(createHistory: HistoryModule.CreateHistory<T>): CreateRouterHistory;
+}
+
 
 declare module "react-router" {
 
@@ -434,6 +442,8 @@ declare module "react-router" {
 
     import match from "react-router/lib/match"
 
+    import useRouterHistory from "react-router/lib/useRouterHistory";
+
     // PlainRoute is defined in the API documented at:
     // https://github.com/rackt/react-router/blob/master/docs/API.md
     // but not included in any of the .../lib modules above.
@@ -472,7 +482,8 @@ declare module "react-router" {
         formatPattern,
         RouterContext,
         PropTypes,
-        match
+        match,
+        useRouterHistory
     }
 
     export default Router
diff --git a/react-select/react-select-0.9.10-tests.tsx b/react-select/react-select-0.9.10-tests.tsx
new file mode 100644
index 000000000..e0a25b203
--- /dev/null
+++ b/react-select/react-select-0.9.10-tests.tsx
@@ -0,0 +1,29 @@
+
+/// <reference path="../react/react.d.ts" />
+/// <reference path="../react/react-dom.d.ts" />
+/// <reference path="./react-select-0.9.10.d.ts" />
+
+import * as React from "react"
+import * as ReactDOM from "react-dom"
+
+import Select from "react-select"
+
+class SelectTest extends React.Component<React.Props<{}>, {}> {
+
+    render() {
+        return <div>
+           <Select />
+        </div>
+    }
+
+}
+
+class SelectAsyncTest extends React.Component<React.Props<{}>, {}> {
+
+    render() {
+        return <div>
+           <Select.Async />
+        </div>
+    }
+
+}
diff --git a/react-select/react-select-0.9.10.d.ts b/react-select/react-select-0.9.10.d.ts
new file mode 100644
index 000000000..60e6bff5f
--- /dev/null
+++ b/react-select/react-select-0.9.10.d.ts
@@ -0,0 +1,80 @@
+// Type definitions for react-select v0.9.10
+// Project: https://github.com/JedWatson/react-select
+// Definitions by: ESQUIBET Hugo <https://github.com/Hesquibet/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference path="../react/react.d.ts"/>
+
+// Typings for https://github.com/JedWatson/react-select
+//***Usage***
+// import ReactSelect = require('react-select');
+//  <ReactSelect options={this.options} name="form-field-name" onChange={this._onSelect} value={this.state.Type} />
+
+declare module "react-select" {
+    // Import React
+    import React = require("react");
+
+    interface Option{
+        label : string;
+        value : string;
+    }
+
+    interface ReactSelectProps extends React.Props<ReactSelectClass>{
+        addLabelText? : string;
+        allowCreate? : boolean;
+        autoload? : boolean;
+        backspaceRemoves? : boolean;
+        cacheAsyncResults? : boolean;
+        className? : string;
+        clearable? : boolean;
+        clearAllText? : string;
+        clearValueText? : string;
+        delimiter? : string;
+        disabled? : boolean;
+        filterOption? : (option : Option,filterString : string)=>Option;
+        filterOptions? : (options:Array<Option>,filterString : string,values : Array<Object>)=>Array<Option>;
+        ignoreCase? : boolean; // default true	whether to perform case-insensitive filtering
+        inputProps? : Object;
+        isLoading? : boolean;
+        labelKey? : string;
+        matchPos? : string;
+        matchProp? : string;
+        multi? : boolean;
+        name? : string;
+        newOptionCreator? : ()=>Option;
+        noResultsText? : string;
+        onBlur? : (event : Event)=>void;
+        onChange? : (newValue : string)=>void;
+        onFocus? : (event : Event)=>void;
+        onInputChange? : (inputValue : string)=>void;
+        onOptionLabelClick? : (value : string, event : Event)=>void;
+        optionRenderer? : ()=>void;
+        options? : Array<Option>;
+        placeholder? : string;
+        searchable? : boolean;
+        searchingText? : string;
+        searchPromptText? : string;
+        value? : Option;
+        valueKey? : string;
+        valueRenderer? : ()=>void;
+    }
+
+    interface ReactAsyncSelectProps extends React.Props<ReactSelectClass>{
+        cache? : any;
+        loadOptions? : ()=>void;
+        ignoreAccents? : boolean;
+        isLoading? : boolean;
+        loadingPlaceholder? : string;
+    }
+
+    interface ReactSelect extends  React.ReactElement<ReactSelectProps> { }
+    interface ReactSelectClass extends React.ComponentClass<ReactSelectProps>{}
+
+    interface SelectWithAsync extends ReactSelectClass {
+        Async? : ReactAsyncSelectProps;
+    }
+
+    var ReactSelect: SelectWithAsync;
+
+    export default ReactSelect;
+}
diff --git a/react-select/react-select-tests.tsx b/react-select/react-select-tests.tsx
index 024761fe8..444551a67 100644
--- a/react-select/react-select-tests.tsx
+++ b/react-select/react-select-tests.tsx
@@ -6,24 +6,25 @@
 import * as React from "react"
 import * as ReactDOM from "react-dom"
 
-import Select from "react-select"
+import * as Select from "react-select"
 
 class SelectTest extends React.Component<React.Props<{}>, {}> {
 
-	render() {
-		return <div>
-	       <Select />
-		</div>
-	}
+    render() {
+        const options: ReactSelect.Option[] = [{ label: "Foo", value: "bar" }]
+        return <div>
+           <Select options={options} />
+        </div>
+    }
 
 }
 
 class SelectAsyncTest extends React.Component<React.Props<{}>, {}> {
 
-	render() {
-		return <div>
-	       <Select.Async />
-		</div>
-	}
+    render() {
+        return <div>
+           <Select.Async />
+        </div>
+    }
 
 }
diff --git a/react-select/react-select.d.ts b/react-select/react-select.d.ts
index 60e6bff5f..c9e385a15 100644
--- a/react-select/react-select.d.ts
+++ b/react-select/react-select.d.ts
@@ -1,80 +1,221 @@
-// Type definitions for react-select v0.9.10
+// Type definitions for react-select v1.0.0
 // Project: https://github.com/JedWatson/react-select
-// Definitions by: ESQUIBET Hugo <https://github.com/Hesquibet/>
+// Definitions by: ESQUIBET Hugo <https://github.com/Hesquibet/>, Gilad Gray <https://github.com/giladgray/>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
-///<reference path="../react/react.d.ts"/>
+/// <reference path="../react/react.d.ts"/>
 
-// Typings for https://github.com/JedWatson/react-select
-//***Usage***
-// import ReactSelect = require('react-select');
-//  <ReactSelect options={this.options} name="form-field-name" onChange={this._onSelect} value={this.state.Type} />
+declare namespace ReactSelect {
+    interface Option {
+        /** Text for rendering */
+        label: string;
+        /** Value for searching */
+        value: string | number;
+        /**
+         * Allow this option to be cleared
+         * @default true
+         */
+        clearableValue?: boolean;
+    }
+
+    interface ReactSelectProps extends __React.Props<ReactSelect> {
+        /**
+         * text to display when `allowCreate` is true.
+         * @default 'Add "{label}"?'
+         */
+        addLabelText?: string;
+        /**
+         * blurs the input element after a selection has been made. Handy for lowering the keyboard on mobile devices.
+         * @default false
+         */
+        autoBlur?: boolean;
+        /**
+         * allow new options to be created in multi mode (displays an "Add <option> ?" item
+         * when a value not already in the options array is entered)
+         * @default false
+         */
+        allowCreate?: boolean;
+        /**
+         * whether to auto-load the default async options set
+         * @default true
+         */
+        autoload?: boolean;
+        /**
+         * whether pressing backspace removes the last item when there is no input value
+         * @default true
+         */
+        backspaceRemoves?: boolean;
+        /**
+         * enables the options cache for `asyncOptions`
+         * @default true
+         */
+        cacheAsyncResults?: boolean;
+        /**
+         * CSS className for the outer element
+         */
+        className?: string;
+        /**
+         * whether it is possible to reset value. if enabled, an X button will appear at the right side.
+         * @default true
+         */
+        clearable?: boolean;
+        /**
+         * title for the "clear" control when `multi` is true
+         * @default "Clear all"
+         */
+        clearAllText?: string;
+        /**
+         * title for the "clear" control
+         * @default "Clear value"
+         */
+        clearValueText?: string;
+        /**
+         * delimiter to use to join multiple values
+         * @default ","
+         */
+        delimiter?: string;
+        /**
+         * whether the Select is disabled or not
+         * @default false
+         */
+        disabled?: boolean;
+        /**
+         * method to filter a single option
+         */
+        filterOption?: (option: Option, filter: string) => Option;
+        /**
+         * method to filter the options array
+         */
+        filterOptions?: (options: Array<Option>, filter: string, currentValues: (string | number)[]) => Array<Option>;
+        /**
+         * whether to perform case-insensitive filtering
+         * @default true
+         */
+        ignoreCase?: boolean;
+        /**
+         * custom attributes for the Input (in the Select-control) e.g: {'data-foo': 'bar'}
+         * @default {}
+         */
+        inputProps?: Object;
+        /**
+         * whether the Select is loading externally or not (such as options being loaded).
+         * if true, a loading spinner will be shown at the right side.
+         * @default false
+         */
+        isLoading?: boolean;
+        /**
+         * the option property to use for the label
+         * @default "label"
+         */
+        labelKey?: string;
+        /**
+         * function that calls a callback with the options
+         */
+        loadOptions?: (input: string, callback: (options: Option[]) => any) => any;
+        /**
+         * (any, start) match the start or entire string when filtering
+         * @default "any"
+         */
+        matchPos?: string;
+        /**
+         * (any, label, value) which option property to filter on
+         * @default "any"
+         */
+        matchProp?: string;
+        /**
+         * buffer of px between the base of the dropdown and the viewport to shift if menu doesnt fit in viewport
+         * @default 0
+         */
+        menuBuffer?: number;
+        /**
+         * multi-value input
+         * @default false
+         */
+        multi?: boolean;
+        /**
+         * field name, for hidden `<input>` tag
+         */
+        name?: string;
+        /**
+         * factory to create new options when `allowCreate` is true
+         * @default false
+         */
+        newOptionCreator?: (input: string) => Option;
+        /**
+         * placeholder displayed when there are no matching search results or a falsy value to hide it
+         * @default "No results found"
+         */
+        noResultsText?: string;
+        onBlur?: __React.FocusEventHandler;
+        /**
+         * whether to clear input on blur or not
+         * @default true
+         */
+        onBlurResetsInput?: boolean;
+        onChange?: (newValue: Option | Option[]) => void;
+        onFocus?: __React.FocusEventHandler;
+        onInputChange?: (inputValue: string) => void;
+        onOptionLabelClick?: (value: string, event: Event) => void;
+        /**
+         * function which returns a custom way to render the options in the menu
+         */
+        optionRenderer?: () => void;
+        /**
+         * array of Select options
+         * @default false
+         */
+        options?: Array<Option>;
+        /**
+         * field placeholder, displayed when there's no value
+         * @default "Select..."
+         */
+        placeholder?: string;
+        /**
+         * whether to enable searching feature or not
+         * @default true;
+         */
+        searchable?: boolean;
+        /**
+         * message to display whilst options are loading via asyncOptions, or when `isLoading` is true
+         * @default "Searching..."
+         */
+        searchingText?: string;
+        /**
+         * label to prompt for search input
+         * @default "Type to search"
+         */
+        searchPromptText?: string;
+        /**
+         * initial field value
+         */
+        value?: Option | Option[];
+        /**
+         * the option property to use for the value
+         * @default "value"
+         */
+        valueKey?: string;
+        /**
+         * function which returns a custom way to render the value selected
+         * @default false
+         */
+        valueRenderer?: () => void;
+    }
+
+    interface ReactAsyncSelectProps extends __React.Props<ReactSelect> {
+        cache?: any;
+        loadOptions?: () => void;
+        ignoreAccents?: boolean;
+        isLoading?: boolean;
+        loadingPlaceholder?: string;
+    }
+
+    interface ReactSelect extends  __React.ReactElement<ReactSelectProps> { }
+    interface ReactSelectClass extends __React.ComponentClass<ReactSelectProps> {
+        Async: __React.ComponentClass<ReactAsyncSelectProps>;
+    }
+}
 
 declare module "react-select" {
-    // Import React
-    import React = require("react");
-
-    interface Option{
-        label : string;
-        value : string;
-    }
-
-    interface ReactSelectProps extends React.Props<ReactSelectClass>{
-        addLabelText? : string;
-        allowCreate? : boolean;
-        autoload? : boolean;
-        backspaceRemoves? : boolean;
-        cacheAsyncResults? : boolean;
-        className? : string;
-        clearable? : boolean;
-        clearAllText? : string;
-        clearValueText? : string;
-        delimiter? : string;
-        disabled? : boolean;
-        filterOption? : (option : Option,filterString : string)=>Option;
-        filterOptions? : (options:Array<Option>,filterString : string,values : Array<Object>)=>Array<Option>;
-        ignoreCase? : boolean; // default true	whether to perform case-insensitive filtering
-        inputProps? : Object;
-        isLoading? : boolean;
-        labelKey? : string;
-        matchPos? : string;
-        matchProp? : string;
-        multi? : boolean;
-        name? : string;
-        newOptionCreator? : ()=>Option;
-        noResultsText? : string;
-        onBlur? : (event : Event)=>void;
-        onChange? : (newValue : string)=>void;
-        onFocus? : (event : Event)=>void;
-        onInputChange? : (inputValue : string)=>void;
-        onOptionLabelClick? : (value : string, event : Event)=>void;
-        optionRenderer? : ()=>void;
-        options? : Array<Option>;
-        placeholder? : string;
-        searchable? : boolean;
-        searchingText? : string;
-        searchPromptText? : string;
-        value? : Option;
-        valueKey? : string;
-        valueRenderer? : ()=>void;
-    }
-
-    interface ReactAsyncSelectProps extends React.Props<ReactSelectClass>{
-        cache? : any;
-        loadOptions? : ()=>void;
-        ignoreAccents? : boolean;
-        isLoading? : boolean;
-        loadingPlaceholder? : string;
-    }
-
-    interface ReactSelect extends  React.ReactElement<ReactSelectProps> { }
-    interface ReactSelectClass extends React.ComponentClass<ReactSelectProps>{}
-
-    interface SelectWithAsync extends ReactSelectClass {
-        Async? : ReactAsyncSelectProps;
-    }
-
-    var ReactSelect: SelectWithAsync;
-
-    export default ReactSelect;
+    var select: ReactSelect.ReactSelectClass;
+    export = select;
 }
diff --git a/react-swf/react-swf.d.ts b/react-swf/react-swf.d.ts
index 374ec876a..21921f8f9 100644
--- a/react-swf/react-swf.d.ts
+++ b/react-swf/react-swf.d.ts
@@ -113,7 +113,6 @@ declare module rswf {
         flashvars?: Object | string
     }
     export class ReactSWF extends __React.Component<Props, State>{
-        render(): __React.DOMElement<any>
         /**
         * Returns the Flash Player object DOM node.
         * Should be prefered over `React.findDOMNode`.
diff --git a/react-swipeable-views/react-swipeable-views-tests.ts b/react-swipeable-views/react-swipeable-views-tests.ts
new file mode 100644
index 000000000..ada49577a
--- /dev/null
+++ b/react-swipeable-views/react-swipeable-views-tests.ts
@@ -0,0 +1,31 @@
+/// <reference path="react-swipeable-views.d.ts"/>
+
+import * as React from 'react';
+import SwipeableViews from 'react-swipeable-views';
+
+const onChangeIndex = (indexNew:number, indexLatest:number) => {
+    console.log('New index: ' + indexNew + ', latest index' + indexLatest);
+};
+
+const onSwitching = (index:number) => {
+    console.log('Switching to ' + index);
+};
+
+const style:React.CSSProperties = {
+    height: 300
+};
+
+React.createElement(SwipeableViews, {
+    containerStyle: style,
+    disabled: false,
+    index: 0,
+    onChangeIndex: onChangeIndex,
+    onSwitching: onSwitching,
+    resistance: false,
+    slideStyle: style,
+    style: style,
+    threshold: 100
+});
+
+
+React.createElement(SwipeableViews, {});
diff --git a/react-swipeable-views/react-swipeable-views.d.ts b/react-swipeable-views/react-swipeable-views.d.ts
new file mode 100644
index 000000000..9c85ad0df
--- /dev/null
+++ b/react-swipeable-views/react-swipeable-views.d.ts
@@ -0,0 +1,37 @@
+// Type definitions for react-swipeable-views
+// Project: https://github.com/oliviertassinari/react-swipeable-views
+// Definitions by: Michael Ledin <https://github.com/mxl>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+///<reference path='../react/react.d.ts' />
+
+declare namespace ReactSwipeableViews {
+    import React = __React;
+
+    export interface SwipeableViewsProps extends React.Props<SwipeableViews> {
+        containerStyle?: React.CSSProperties;
+        disabled?: boolean;
+        index?: number;
+        onChangeIndex?: (indexNew:number, indexLatest:number) => void;
+        onSwitching?: (index:number) => void;
+        resistance?: boolean;
+        slideStyle?: React.CSSProperties;
+        style?: React.CSSProperties;
+        threshold?: number;
+    }
+
+    interface SwipeableViewsState {
+        indexCurrent?: number;
+        indexLatest?: number;
+        isDragging?: boolean;
+        isFirstRender?: boolean;
+        heightLatest?: number;
+    }
+
+    export class SwipeableViews extends React.Component<SwipeableViewsProps, SwipeableViewsState> {
+    }
+}
+
+declare module 'react-swipeable-views' {
+    export default ReactSwipeableViews.SwipeableViews;
+}
diff --git a/react/README.md b/react/README.md
index 8990e8a71..1adf43f60 100644
--- a/react/README.md
+++ b/react/README.md
@@ -1,5 +1,81 @@
-# React v0.14.2 Type Definitions
+# React v0.14.4 Type Definitions
 
-If you are using modules you should use `react.d.ts`, `react-dom.d.ts` and any of the `react-addon-*.d.ts` definition files.
+This directory contains type definitions for the following React packages:
+- `react`
+- `react-addons-create-fragment`
+- `react-addons-css-transition-group`
+- `react-addons-linked-state-mixin`
+- `react-addons-perf`
+- `react-addons-pure-render-mixin`
+- `react-addons-shallow-compare`
+- `react-addons-test-utils`
+- `react-addons-transition-group`
+- `react-addons-update`
+- `react-dom`
 
-If you are using the global `React` variable, you should use `react-global.d.ts`.
+## Getting Started
+If you are using modules you should use `react.d.ts`, `react-dom.d.ts` or any of the `react-addons-*.d.ts` definition files. If `React` is in your global namespace, you should use `react-global.d.ts`.
+
+## Known Problems & Workarounds
+
+### **The type of `setState` is incorrect.**
+The `setState(state)` method on `React.Component<P, S>` takes an object with a subset of the properties on `S`, but there's no way to express this in TypeScript currently. The workaround is simple: make all properties on `S` optional. There are a number of [proposals](https://github.com/Microsoft/TypeScript/issues/2710) on [ways](https://github.com/Microsoft/TypeScript/issues/4889) to [solve](https://github.com/Microsoft/TypeScript/issues/7355) this problem, but nothing seems to have been approved yet.
+  
+### **The type of `cloneElement` is incorrect.**
+This is similar to the `setState` problem, in that `cloneElement(element, props)` should should accept a `props` object with a subset of the properties on `element.props`. There is an additional complication, however—React attributes, such as `key` and `ref`, should also be accepted in `props`, but should not exist on `element.props`. The "correct" way to model this, then, is with
+```ts
+declare function cloneElement<P extends Q, Q>(
+    element: ReactElement<P>,
+    props?: Q & Attributes,
+    ...children: ReactNode[]): ReactElement<P>;
+```
+However, type inference for `Q` defaults to `{}` when [intersected with another type](https://github.com/Microsoft/TypeScript/pull/5738#issuecomment-181904905). And since any object is assignable to `{}`, we would lose the type safety of the `P extends Q` constraint. Therefore, the type of `props` is left as `Q`, which should work for most cases. If you need to call `cloneElement` with `key` or `ref`, you'll need a type cast:
+```ts
+interface ButtonProps {
+    label: string,
+    isDisabled?: boolean;
+}
+var element: React.CElement<ButtonProps, Button>;
+
+React.cloneElement(element, { label: "label" });
+
+// cloning with optional props requires a cast
+React.cloneElement(element, <{ isDisabled?: boolean }>{ isDisabled: true });
+
+// cloning with key or ref requires a cast
+React.cloneElement(element, <React.ClassAttributes<Button>>{ ref: button => button.reset() });
+React.cloneElement(element, <{ isDisabled?: boolean } & React.Attributes>{
+    key: "disabledButton",
+    isDisabled: true
+});
+```
+
+### **`React.Component<P, S>` subclass members aren't contextually typed.**
+This problem manifests itself in two ways. It should be fixed in [TypeScript 2.0](https://github.com/Microsoft/TypeScript/pull/6118).
+
+  - You might expect `componentDidUpdate(prevProps, prevState)` to have `prevProps` and `prevState` contextually typed as `P` and `S` respectively, but currently that is not the case. You must explicitly type-annotate both arguments.
+  
+  - You may get a cryptic error message when either `React.createElement` or `React.createFactory` doesn't recognize the `type` argument that you passed in as a valid `React.Component` subclass, because you overrode one of the static or instance members with a type that's not compatible with the superclass property's type. For example, with the following code:
+    ```ts
+    import * as React from "react";
+
+    class MyComponent extends React.Component<Props, {}> {
+        static contextTypes = {
+            someValue: React.PropTypes.string
+        };
+    }
+
+    React.createFactory(MyComponent);
+    ```
+    you might get this error:
+    ```
+    error TS2345: Argument of type 'typeof MyComponent' is not assignable to parameter of type 'string | ComponentClass<Props> | StatelessComponent<Props>'
+      Type 'typeof ModernComponent' is not assignable to type 'StatelessComponent<Props>'.
+        Types of property 'contextTypes' are incompatible.
+          Type '{ someValue: Requireable<any>; }' is not assignable to type 'ValidationMap<any>'.
+            Index signature is missing in type '{ someValue: Requireable<any>; }'.
+    ```
+    The work around is to add an explicit type annotation:
+    ```ts
+    static contextTypes: React.ValidationMap<any> = ...
+    ```
diff --git a/react/react-addons-test-utils.d.ts b/react/react-addons-test-utils.d.ts
index d71976ef6..35df25102 100644
--- a/react/react-addons-test-utils.d.ts
+++ b/react/react-addons-test-utils.d.ts
@@ -94,23 +94,31 @@ declare namespace __React {
                 export var wheel: EventSimulator;
             }
 
+            export function renderIntoDocument<T extends Element>(
+                element: DOMElement<any, T>): T;
             export function renderIntoDocument(
-                element: DOMElement<any>): Element;
+                element: SFCElement<any>): void;
+            export function renderIntoDocument<T extends Component<any, any>>(
+                element: CElement<any, T>): T;
             export function renderIntoDocument<P>(
-                element: ReactElement<P>): Component<P, any>;
-            export function renderIntoDocument<C extends Component<any, any>>(
-                element: ReactElement<any>): C;
+                element: ReactElement<P>): Component<P, {}> | Element | void;
 
             export function mockComponent(
                 mocked: MockedComponentClass, mockTagName?: string): typeof TestUtils;
 
-            export function isElementOfType(
-                element: ReactElement<any>, type: ReactType): boolean;
-            export function isDOMComponent(instance: ReactInstance): boolean;
-            export function isCompositeComponent(instance: ReactInstance): boolean;
-            export function isCompositeComponentWithType(
-                instance: ReactInstance,
-                type: ComponentClass<any>): boolean;
+            export function isElementOfType<T extends HTMLElement>(
+                element: ReactElement<any>, type: string): element is ReactHTMLElement<T>;
+            export function isElementOfType<P extends DOMAttributes, T extends Element>(
+                element: ReactElement<any>, type: string): element is DOMElement<P, T>;
+            export function isElementOfType<P>(
+                element: ReactElement<any>, type: SFC<P>): element is SFCElement<P>;
+            export function isElementOfType<P, T extends Component<P, {}>, C extends ComponentClass<P>>(
+                element: ReactElement<any>, type: ClassType<P, T, C>): element is CElement<P, T>;
+
+            export function isDOMComponent(instance: ReactInstance): instance is Element;
+            export function isCompositeComponent(instance: ReactInstance): instance is Component<any, any>;
+            export function isCompositeComponentWithType<T extends Component<any, any>, C extends ComponentClass<any>>(
+                instance: ReactInstance, type: ClassType<any, T, C>): T;
 
             export function findAllInRenderedTree(
                 root: Component<any, any>,
@@ -130,13 +138,13 @@ declare namespace __React {
                 root: Component<any, any>,
                 tagName: string): Element;
 
-            export function scryRenderedComponentsWithType<T extends Component<{}, {}>>(
+            export function scryRenderedComponentsWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
                 root: Component<any, any>,
-                type: { new(): T }): T[];
+                type: ClassType<any, T, C>): T[];
 
-            export function findRenderedComponentWithType<T extends Component<{}, {}>>(
+            export function findRenderedComponentWithType<T extends Component<{}, {}>, C extends ComponentClass<{}>>(
                 root: Component<any, any>,
-                type: { new(): T }): T;
+                type: ClassType<any, T, C>): T;
 
             export function createRenderer(): ShallowRenderer;
         }
diff --git a/react/react-dom.d.ts b/react/react-dom.d.ts
index 80a0c604e..492b546d1 100644
--- a/react/react-dom.d.ts
+++ b/react/react-dom.d.ts
@@ -10,18 +10,22 @@ declare namespace __React {
         function findDOMNode<E extends Element>(instance: ReactInstance): E;
         function findDOMNode(instance: ReactInstance): Element;
 
+        function render<P extends DOMAttributes, T extends Element>(
+            element: DOMElement<P, T>,
+            container: Element,
+            callback?: (element: T) => any): T;
         function render<P>(
-            element: DOMElement<P>,
+            element: SFCElement<P>,
             container: Element,
-            callback?: (element: Element) => any): Element;
-        function render<P, S>(
-            element: ClassicElement<P>,
+            callback?: () => any): void;
+        function render<P, T extends Component<P, {}>>(
+            element: CElement<P, T>,
             container: Element,
-            callback?: (component: ClassicComponent<P, S>) => any): ClassicComponent<P, S>;
-        function render<P, S>(
+            callback?: (component: T) => any): T;
+        function render<P>(
             element: ReactElement<P>,
             container: Element,
-            callback?: (component: Component<P, S>) => any): Component<P, S>;
+            callback?: (component?: Component<P, {}> | Element) => any): Component<P, {}> | Element | void;
 
         function unmountComponentAtNode(container: Element): boolean;
 
@@ -31,21 +35,26 @@ declare namespace __React {
         function unstable_batchedUpdates<A>(callback: (a: A) => any, a: A): void;
         function unstable_batchedUpdates(callback: () => any): void;
 
+        function unstable_renderSubtreeIntoContainer<P extends DOMAttributes, T extends Element>(
+            parentComponent: Component<any, any>,
+            element: DOMElement<P, T>,
+            container: Element,
+            callback?: (element: T) => any): T;
+        function unstable_renderSubtreeIntoContainer<P, T extends Component<P, {}>>(
+            parentComponent: Component<any, any>,
+            element: CElement<P, T>,
+            container: Element,
+            callback?: (component: T) => any): T;
+        function render<P>(
+            parentComponent: Component<any, any>,
+            element: SFCElement<P>,
+            container: Element,
+            callback?: () => any): void;
         function unstable_renderSubtreeIntoContainer<P>(
             parentComponent: Component<any, any>,
-            nextElement: DOMElement<P>,
+            element: ReactElement<P>,
             container: Element,
-            callback?: (element: Element) => any): Element;
-        function unstable_renderSubtreeIntoContainer<P, S>(
-            parentComponent: Component<any, any>,
-            nextElement: ClassicElement<P>,
-            container: Element,
-            callback?: (component: ClassicComponent<P, S>) => any): ClassicComponent<P, S>;
-        function unstable_renderSubtreeIntoContainer<P, S>(
-            parentComponent: Component<any, any>,
-            nextElement: ReactElement<P>,
-            container: Element,
-            callback?: (component: Component<P, S>) => any): Component<P, S>;
+            callback?: (component?: Component<P, {}> | Element) => any): Component<P, {}> | Element | void;
     }
 
     namespace __DOMServer {
diff --git a/react/react-global-tests.ts b/react/react-global-tests.ts
index ac8b85116..3aaf4b2c1 100644
--- a/react/react-global-tests.ts
+++ b/react/react-global-tests.ts
@@ -1,6 +1,6 @@
 /// <reference path="react-global.d.ts" />
 
-interface Props extends React.Props<MyComponent> {
+interface Props {
     hello: string;
     world?: string;
     foo: number;
@@ -24,7 +24,7 @@ interface MyComponent extends React.Component<Props, State> {
     reset(): void;
 }
 
-var props: Props = {
+var props: Props & React.ClassAttributes<{}> = {
     key: 42,
     ref: "myComponent42",
     hello: "world",
@@ -115,9 +115,9 @@ class ModernComponent extends React.Component<Props, State>
 }
 
 // React.createFactory
-var factory: React.Factory<Props> =
+var factory: React.CFactory<Props, ModernComponent> =
     React.createFactory(ModernComponent);
-var factoryElement: React.ReactElement<Props> =
+var factoryElement: React.CElement<Props, ModernComponent> =
     factory(props);
 
 var classicFactory: React.ClassicFactory<Props> =
@@ -125,25 +125,25 @@ var classicFactory: React.ClassicFactory<Props> =
 var classicFactoryElement: React.ClassicElement<Props> =
     classicFactory(props);
 
-var domFactory: React.DOMFactory<any> =
+var domFactory: React.DOMFactory<React.DOMAttributes, Element> =
     React.createFactory("foo");
-var domFactoryElement: React.DOMElement<any> =
+var domFactoryElement: React.DOMElement<React.DOMAttributes, Element> =
     domFactory();
 
 // React.createElement
-var element: React.ReactElement<Props> =
+var element: React.CElement<Props, ModernComponent> =
     React.createElement(ModernComponent, props);
 var classicElement: React.ClassicElement<Props> =
     React.createElement(ClassicComponent, props);
-var domElement: React.ReactHTMLElement =
+var domElement: React.ReactHTMLElement<HTMLDivElement> =
     React.createElement("div");
 
 // React.cloneElement
-var clonedElement: React.ReactElement<Props> =
+var clonedElement: React.CElement<Props, ModernComponent> =
     React.cloneElement(element, props);
 var clonedClassicElement: React.ClassicElement<Props> =
     React.cloneElement(classicElement, props);
-var clonedDOMElement: React.ReactHTMLElement =
+var clonedDOMElement: React.ReactHTMLElement<HTMLDivElement> =
     React.cloneElement(domElement);
 
 // React.render
diff --git a/react/react-tests.ts b/react/react-tests.ts
index 9147194dc..e0d9bb7be 100644
--- a/react/react-tests.ts
+++ b/react/react-tests.ts
@@ -23,7 +23,7 @@ import TestUtils = require("react-addons-test-utils");
 import TransitionGroup = require("react-addons-transition-group");
 import update = require("react-addons-update");
 
-interface Props extends React.Props<MyComponent> {
+interface Props {
     hello: string;
     world?: string;
     foo: number;
@@ -46,7 +46,7 @@ interface MyComponent extends React.Component<Props, State> {
     reset(): void;
 }
 
-var props: Props = {
+var props: Props & React.ClassAttributes<{}> = {
     key: 42,
     ref: "myComponent42",
     hello: "world",
@@ -138,31 +138,35 @@ class ModernComponent extends React.Component<Props, State>
     }
 }
 
-interface SCProps extends React.Props<{}> {
+interface SCProps {
     foo?: number;
 }
 
-var StatelessComponent = (props: SCProps) => {
+function StatelessComponent(props: SCProps) {
     return React.DOM.div(null, props.foo);
 };
+namespace StatelessComponent {
+    export var displayName = "StatelessComponent";
+    export var defaultProps = { foo: 42 };
+}
 
-// Must explicitly type-annotate to add displayName/defaultProps/contextTypes
-var StatelessComponent2: React.StatelessComponent<SCProps> =
-    (props: SCProps) => React.DOM.div(null, props.foo);
+var StatelessComponent2: React.SFC<SCProps> =
+    // props is contextually typed
+    props => React.DOM.div(null, props.foo);
 StatelessComponent2.displayName = "StatelessComponent2";
 StatelessComponent2.defaultProps = {
     foo: 42
 };
 
 // React.createFactory
-var factory: React.Factory<Props> =
+var factory: React.CFactory<Props, ModernComponent> =
     React.createFactory(ModernComponent);
-var factoryElement: React.ReactElement<Props> =
+var factoryElement: React.CElement<Props, ModernComponent> =
     factory(props);
 
-var statelessFactory: React.Factory<SCProps> =
+var statelessFactory: React.SFCFactory<SCProps> =
     React.createFactory(StatelessComponent);
-var statelessElement: React.ReactElement<SCProps> =
+var statelessElement: React.SFCElement<SCProps> =
     statelessFactory(props);
 
 var classicFactory: React.ClassicFactory<Props> =
@@ -170,37 +174,47 @@ var classicFactory: React.ClassicFactory<Props> =
 var classicFactoryElement: React.ClassicElement<Props> =
     classicFactory(props);
 
-var domFactory: React.DOMFactory<any> =
+var domFactory: React.DOMFactory<React.DOMAttributes, Element> =
     React.createFactory("foo");
-var domFactoryElement: React.DOMElement<any> =
+var domFactoryElement: React.DOMElement<React.DOMAttributes, Element> =
     domFactory();
 
 // React.createElement
-var element: React.ReactElement<Props> =
+var element: React.CElement<Props, ModernComponent> =
     React.createElement(ModernComponent, props);
-var statelessElement: React.ReactElement<SCProps> =
+var statelessElement: React.SFCElement<SCProps> =
     React.createElement(StatelessComponent, props);
 var classicElement: React.ClassicElement<Props> =
     React.createElement(ClassicComponent, props);
-var domElement: React.ReactHTMLElement =
+var domElement: React.ReactHTMLElement<HTMLDivElement> =
     React.createElement("div");
 
 // React.cloneElement
-var clonedElement: React.ReactElement<Props> =
+var clonedElement: React.CElement<Props, ModernComponent> =
     React.cloneElement(element, { foo: 43 });
-var clonedStatelessElement: React.ReactElement<SCProps> =
+var clonedElement2: React.CElement<Props, ModernComponent> =
+    // known problem: cloning with key or ref requires cast
+    React.cloneElement(element, <React.ClassAttributes<ModernComponent>>{
+        ref: c => c.reset()
+    });
+var clonedElement3: React.CElement<Props, ModernComponent> =
+    React.cloneElement(element, <{ foo: number } & React.Attributes>{
+        key: "8eac7",
+        foo: 55
+    });
+var clonedStatelessElement: React.SFCElement<SCProps> =
     // known problem: cloning with optional props don't work properly
     // workaround: cast to actual props type
     React.cloneElement(statelessElement, <SCProps>{ foo: 44 });
 var clonedClassicElement: React.ClassicElement<Props> =
     React.cloneElement(classicElement, props);
-var clonedDOMElement: React.ReactHTMLElement =
+var clonedDOMElement: React.ReactHTMLElement<HTMLDivElement> =
     React.cloneElement(domElement, {
         className: "clonedElement"
     });
 
 // React.render
-var component: React.Component<Props, any> =
+var component: ModernComponent =
     ReactDOM.render(element, container);
 var classicComponent: React.ClassicComponent<Props, any> =
     ReactDOM.render(classicElement, container);
@@ -220,9 +234,12 @@ domNode = ReactDOM.findDOMNode(domNode);
 // React Elements
 // --------------------------------------------------------------------------
 
-var type = element.type;
+var type: React.ComponentClass<Props> = element.type;
 var elementProps: Props = element.props;
-var key = element.key;
+var key: React.Key = element.key;
+
+var t: React.ReactType;
+var name = typeof t === "string" ? t : t.displayName;
 
 //
 // React Components
@@ -250,12 +267,9 @@ myComponent.reset();
 
 //
 // Refs
-// NB: to infer the correct type for callback refs, your component's Props
-// interface must extend React.Props<T> where T is your component type (or
-// an interface that it implements).
 // --------------------------------------------------------------------------
 
-interface RCProps extends React.Props<RefComponent> {
+interface RCProps {
 }
 
 class RefComponent extends React.Component<RCProps, {}> {
@@ -546,6 +560,20 @@ var foundComponent: ModernComponent = TestUtils.findRenderedComponentWithType(
 var foundComponents: ModernComponent[] = TestUtils.scryRenderedComponentsWithType(
     inst, ModernComponent);
 
+// ReactTestUtils custom type guards
+
+var emptyElement: React.ReactElement<{}>;
+if (TestUtils.isElementOfType(emptyElement, StatelessComponent)) {
+    emptyElement.props.foo;
+}
+
+var anyInstance: Element | React.Component<any, any>;
+if (TestUtils.isDOMComponent(anyInstance)) {
+    anyInstance.getAttribute("className");
+} else if (TestUtils.isCompositeComponent(anyInstance)) {
+    anyInstance.props;
+}
+
 //
 // TransitionGroup addon
 // --------------------------------------------------------------------------
diff --git a/react/react.d.ts b/react/react.d.ts
index f4369e4a1..22d7c16ca 100644
--- a/react/react.d.ts
+++ b/react/react.d.ts
@@ -10,32 +10,44 @@ declare namespace __React {
     // ----------------------------------------------------------------------
 
     type ReactType = string | ComponentClass<any> | StatelessComponent<any>;
+
     type Key = string | number;
     type Ref<T> = string | ((instance: T) => any);
 
-    interface ReactElement<P extends Props<any>> {
-        type: string | ComponentClass<P> | StatelessComponent<P>;
+    interface Attributes {
+        key?: Key;
+    }
+    interface ClassAttributes<T> extends Attributes {
+        ref?: Ref<T>;
+    }
+
+    interface ReactElement<P> {
+        type: string | ComponentClass<P> | SFC<P>;
         props: P;
-        key: Key;
-        ref: Ref<Component<P, any> | Element>;
+        key?: Key;
     }
 
-    interface ClassicElement<P> extends ReactElement<P> {
-        type: ClassicComponentClass<P>;
-        ref: Ref<ClassicComponent<P, any>>;
+    interface SFCElement<P> extends ReactElement<P> {
+        type: SFC<P>;
     }
 
-    interface DOMElement<P extends Props<Element>> extends ReactElement<P> {
+    type CElement<P, T extends Component<P, {}>> = ComponentElement<P, T>;
+    interface ComponentElement<P, T extends Component<P, {}>> extends ReactElement<P> {
+        type: ComponentClass<P>;
+        ref?: Ref<T>;
+    }
+
+    type ClassicElement<P> = CElement<P, ClassicComponent<P, {}>>;
+
+    interface DOMElement<P extends DOMAttributes, T extends Element> extends ReactElement<P> {
         type: string;
-        ref: Ref<Element>;
+        ref: Ref<T>;
     }
 
-    interface ReactHTMLElement extends DOMElement<HTMLProps<HTMLElement>> {
-        ref: Ref<HTMLElement>;
+    interface ReactHTMLElement<T extends HTMLElement> extends DOMElement<HTMLAttributes, T> {
     }
 
-    interface ReactSVGElement extends DOMElement<SVGProps> {
-        ref: Ref<SVGElement>;
+    interface ReactSVGElement extends DOMElement<SVGAttributes, SVGElement> {
     }
 
     //
@@ -43,19 +55,29 @@ declare namespace __React {
     // ----------------------------------------------------------------------
 
     interface Factory<P> {
-        (props?: P, ...children: ReactNode[]): ReactElement<P>;
+        (props?: P & Attributes, ...children: ReactNode[]): ReactElement<P>;
     }
 
-    interface ClassicFactory<P> extends Factory<P> {
-        (props?: P, ...children: ReactNode[]): ClassicElement<P>;
+    interface SFCFactory<P> {
+        (props?: P & Attributes, ...children: ReactNode[]): SFCElement<P>;
     }
 
-    interface DOMFactory<P extends Props<Element>> extends Factory<P> {
-        (props?: P, ...children: ReactNode[]): DOMElement<P>;
+    interface ComponentFactory<P, T extends Component<P, {}>> {
+        (props?: P & ClassAttributes<T>, ...children: ReactNode[]): CElement<P, T>;
     }
 
-    type HTMLFactory = DOMFactory<HTMLProps<HTMLElement>>;
-    type SVGFactory = DOMFactory<SVGProps>;
+    type CFactory<P, T extends Component<P, {}>> = ComponentFactory<P, T>;
+    type ClassicFactory<P> = CFactory<P, ClassicComponent<P, {}>>;
+
+    interface DOMFactory<P extends DOMAttributes, T extends Element> {
+        (props?: P & ClassAttributes<T>, ...children: ReactNode[]): DOMElement<P, T>;
+    }
+
+    interface HTMLFactory<T extends HTMLElement> extends DOMFactory<HTMLAttributes, T> {
+    }
+
+    interface SVGFactory extends DOMFactory<SVGAttributes, SVGElement> {
+    }
 
     //
     // React Nodes
@@ -75,41 +97,54 @@ declare namespace __React {
 
     function createClass<P, S>(spec: ComponentSpec<P, S>): ClassicComponentClass<P>;
 
-    function createFactory<P>(type: string): DOMFactory<P>;
-    function createFactory<P>(type: ClassicComponentClass<P>): ClassicFactory<P>;
-    function createFactory<P>(type: ComponentClass<P> | StatelessComponent<P>): Factory<P>;
+    function createFactory<P extends DOMAttributes, T extends Element>(
+        type: string): DOMFactory<P, T>;
+    function createFactory<P>(type: SFC<P>): SFCFactory<P>;
+    function createFactory<P>(
+        type: ClassType<P, ClassicComponent<P, {}>, ClassicComponentClass<P>>): CFactory<P, ClassicComponent<P, {}>>;
+    function createFactory<P, T extends Component<P, {}>, C extends ComponentClass<P>>(
+        type: ClassType<P, T, C>): CFactory<P, T>;
+    function createFactory<P>(type: ComponentClass<P> | SFC<P>): Factory<P>;
 
-    function createElement<P>(
+    function createElement<P extends DOMAttributes, T extends Element>(
         type: string,
-        props?: P,
-        ...children: ReactNode[]): DOMElement<P>;
+        props?: P & ClassAttributes<T>,
+        ...children: ReactNode[]): DOMElement<P, T>;
     function createElement<P>(
-        type: ClassicComponentClass<P>,
-        props?: P,
-        ...children: ReactNode[]): ClassicElement<P>;
+        type: SFC<P>,
+        props?: P & Attributes,
+        ...children: ReactNode[]): SFCElement<P>;
     function createElement<P>(
-        type: ComponentClass<P> | StatelessComponent<P>,
-        props?: P,
+        type: ClassType<P, ClassicComponent<P, {}>, ClassicComponentClass<P>>,
+        props?: P & ClassAttributes<ClassicComponent<P, {}>>,
+        ...children: ReactNode[]): CElement<P, ClassicComponent<P, {}>>;
+    function createElement<P, T extends Component<P, {}>, C extends ComponentClass<P>>(
+        type: ClassType<P, T, C>,
+        props?: P & ClassAttributes<T>,
+        ...children: ReactNode[]): CElement<P, T>;
+    function createElement<P>(
+        type: ComponentClass<P> | SFC<P>,
+        props?: P & Attributes,
         ...children: ReactNode[]): ReactElement<P>;
 
-    function cloneElement(
-        element: ReactHTMLElement,
-        props?: HTMLProps<HTMLElement>,
-        ...children: ReactNode[]): ReactHTMLElement;
-    function cloneElement(
-        element: ReactSVGElement,
-        props?: SVGProps,
-        ...children: ReactNode[]): ReactSVGElement;
+    function cloneElement<P extends DOMAttributes, T extends Element>(
+        element: DOMElement<P, T>,
+        props?: P & ClassAttributes<T>,
+        ...children: ReactNode[]): DOMElement<P, T>;
     function cloneElement<P extends Q, Q>(
-        element: ClassicElement<P>,
-        props?: Q,
-        ...children: ReactNode[]): ClassicElement<P>;
+        element: SFCElement<P>,
+        props?: Q, // should be Q & Attributes, but then Q is inferred as {}
+        ...children: ReactNode[]): SFCElement<P>;
+    function cloneElement<P extends Q, Q, T extends Component<P, {}>>(
+        element: CElement<P, T>,
+        props?: Q, // should be Q & ClassAttributes<T>
+        ...children: ReactNode[]): CElement<P, T>;
     function cloneElement<P extends Q, Q>(
         element: ReactElement<P>,
-        props?: Q,
+        props?: Q, // should be Q & Attributes
         ...children: ReactNode[]): ReactElement<P>;
 
-    function isValidElement(object: {}): boolean;
+    function isValidElement<P>(object: {}): object is ReactElement<P>;
 
     var DOM: ReactDOM;
     var PropTypes: ReactPropTypes;
@@ -128,7 +163,13 @@ declare namespace __React {
         setState(state: S, callback?: () => any): void;
         forceUpdate(callBack?: () => any): void;
         render(): JSX.Element;
-        props: P;
+
+        // React.Props<T> is now deprecated, which means that the `children`
+        // property is not available on `P` by default, even though you can
+        // always pass children as variadic arguments to `createElement`.
+        // In the future, if we can define its call signature conditionallly
+        // on the existence of `children` in `P`, then we should remove this.
+        props: P & { children?: ReactNode };
         state: S;
         context: {};
         refs: {
@@ -150,6 +191,7 @@ declare namespace __React {
     // Class Interfaces
     // ----------------------------------------------------------------------
 
+    type SFC<P> = StatelessComponent<P>;
     interface StatelessComponent<P> {
         (props?: P, context?: any): ReactElement<any>;
         propTypes?: ValidationMap<P>;
@@ -159,19 +201,29 @@ declare namespace __React {
     }
 
     interface ComponentClass<P> {
-        new(props?: P, context?: any): Component<P, any>;
+        new(props?: P, context?: any): Component<P, {}>;
         propTypes?: ValidationMap<P>;
         contextTypes?: ValidationMap<any>;
         childContextTypes?: ValidationMap<any>;
         defaultProps?: P;
+        displayName?: string;
     }
 
     interface ClassicComponentClass<P> extends ComponentClass<P> {
-        new(props?: P, context?: any): ClassicComponent<P, any>;
+        new(props?: P, context?: any): ClassicComponent<P, {}>;
         getDefaultProps?(): P;
-        displayName?: string;
     }
 
+    /**
+     * We use an intersection type to infer multiple type parameters from
+     * a single argument, which is useful for many top-level API defs.
+     * See https://github.com/Microsoft/TypeScript/issues/7234 for more info.
+     */
+    type ClassType<P, T extends Component<P, {}>, C extends ComponentClass<P>> =
+        C &
+        (new() => T) &
+        (new() => { props: P });
+
     //
     // Component Specs and Lifecycle
     // ----------------------------------------------------------------------
@@ -325,19 +377,34 @@ declare namespace __React {
     // Props / DOM Attributes
     // ----------------------------------------------------------------------
 
+    /**
+     * @deprecated. This was used to allow clients to pass `ref` and `key`
+     * to `createElement`, which is no longer necessary due to intersection
+     * types. If you need to declare a props object before passing it to
+     * `createElement` or a factory, use `ClassAttributes<T>`:
+     *
+     * ```ts
+     * var b: Button;
+     * var props: ButtonProps & ClassAttributes<Button> = {
+     *     ref: b => button = b, // ok!
+     *     label: "I'm a Button"
+     * };
+     * ```
+     */
     interface Props<T> {
         children?: ReactNode;
         key?: Key;
         ref?: Ref<T>;
     }
 
-    interface HTMLProps<T> extends HTMLAttributes, Props<T> {
+    interface HTMLProps<T> extends HTMLAttributes, ClassAttributes<T> {
     }
 
-    interface SVGProps extends SVGAttributes, Props<SVGElement> {
+    interface SVGProps extends SVGAttributes, ClassAttributes<SVGElement> {
     }
 
     interface DOMAttributes {
+        children?: ReactNode;
         dangerouslySetInnerHTML?: {
             __html: string;
         };
@@ -1898,6 +1965,7 @@ declare namespace __React {
         multiple?: boolean;
         muted?: boolean;
         name?: string;
+        nonce?: string;
         noValidate?: boolean;
         open?: boolean;
         optimum?: number;
@@ -1909,6 +1977,7 @@ declare namespace __React {
         readOnly?: boolean;
         rel?: string;
         required?: boolean;
+        reversed?: boolean;
         role?: string;
         rows?: number;
         rowSpan?: number;
@@ -2033,119 +2102,119 @@ declare namespace __React {
 
     interface ReactDOM {
         // HTML
-        a: HTMLFactory;
-        abbr: HTMLFactory;
-        address: HTMLFactory;
-        area: HTMLFactory;
-        article: HTMLFactory;
-        aside: HTMLFactory;
-        audio: HTMLFactory;
-        b: HTMLFactory;
-        base: HTMLFactory;
-        bdi: HTMLFactory;
-        bdo: HTMLFactory;
-        big: HTMLFactory;
-        blockquote: HTMLFactory;
-        body: HTMLFactory;
-        br: HTMLFactory;
-        button: HTMLFactory;
-        canvas: HTMLFactory;
-        caption: HTMLFactory;
-        cite: HTMLFactory;
-        code: HTMLFactory;
-        col: HTMLFactory;
-        colgroup: HTMLFactory;
-        data: HTMLFactory;
-        datalist: HTMLFactory;
-        dd: HTMLFactory;
-        del: HTMLFactory;
-        details: HTMLFactory;
-        dfn: HTMLFactory;
-        dialog: HTMLFactory;
-        div: HTMLFactory;
-        dl: HTMLFactory;
-        dt: HTMLFactory;
-        em: HTMLFactory;
-        embed: HTMLFactory;
-        fieldset: HTMLFactory;
-        figcaption: HTMLFactory;
-        figure: HTMLFactory;
-        footer: HTMLFactory;
-        form: HTMLFactory;
-        h1: HTMLFactory;
-        h2: HTMLFactory;
-        h3: HTMLFactory;
-        h4: HTMLFactory;
-        h5: HTMLFactory;
-        h6: HTMLFactory;
-        head: HTMLFactory;
-        header: HTMLFactory;
-        hgroup: HTMLFactory;
-        hr: HTMLFactory;
-        html: HTMLFactory;
-        i: HTMLFactory;
-        iframe: HTMLFactory;
-        img: HTMLFactory;
-        input: HTMLFactory;
-        ins: HTMLFactory;
-        kbd: HTMLFactory;
-        keygen: HTMLFactory;
-        label: HTMLFactory;
-        legend: HTMLFactory;
-        li: HTMLFactory;
-        link: HTMLFactory;
-        main: HTMLFactory;
-        map: HTMLFactory;
-        mark: HTMLFactory;
-        menu: HTMLFactory;
-        menuitem: HTMLFactory;
-        meta: HTMLFactory;
-        meter: HTMLFactory;
-        nav: HTMLFactory;
-        noscript: HTMLFactory;
-        object: HTMLFactory;
-        ol: HTMLFactory;
-        optgroup: HTMLFactory;
-        option: HTMLFactory;
-        output: HTMLFactory;
-        p: HTMLFactory;
-        param: HTMLFactory;
-        picture: HTMLFactory;
-        pre: HTMLFactory;
-        progress: HTMLFactory;
-        q: HTMLFactory;
-        rp: HTMLFactory;
-        rt: HTMLFactory;
-        ruby: HTMLFactory;
-        s: HTMLFactory;
-        samp: HTMLFactory;
-        script: HTMLFactory;
-        section: HTMLFactory;
-        select: HTMLFactory;
-        small: HTMLFactory;
-        source: HTMLFactory;
-        span: HTMLFactory;
-        strong: HTMLFactory;
-        style: HTMLFactory;
-        sub: HTMLFactory;
-        summary: HTMLFactory;
-        sup: HTMLFactory;
-        table: HTMLFactory;
-        tbody: HTMLFactory;
-        td: HTMLFactory;
-        textarea: HTMLFactory;
-        tfoot: HTMLFactory;
-        th: HTMLFactory;
-        thead: HTMLFactory;
-        time: HTMLFactory;
-        title: HTMLFactory;
-        tr: HTMLFactory;
-        track: HTMLFactory;
-        u: HTMLFactory;
-        ul: HTMLFactory;
-        "var": HTMLFactory;
-        video: HTMLFactory;
-        wbr: HTMLFactory;
+        a: HTMLFactory<HTMLAnchorElement>;
+        abbr: HTMLFactory<HTMLElement>;
+        address: HTMLFactory<HTMLElement>;
+        area: HTMLFactory<HTMLAreaElement>;
+        article: HTMLFactory<HTMLElement>;
+        aside: HTMLFactory<HTMLElement>;
+        audio: HTMLFactory<HTMLAudioElement>;
+        b: HTMLFactory<HTMLElement>;
+        base: HTMLFactory<HTMLBaseElement>;
+        bdi: HTMLFactory<HTMLElement>;
+        bdo: HTMLFactory<HTMLElement>;
+        big: HTMLFactory<HTMLElement>;
+        blockquote: HTMLFactory<HTMLElement>;
+        body: HTMLFactory<HTMLBodyElement>;
+        br: HTMLFactory<HTMLBRElement>;
+        button: HTMLFactory<HTMLButtonElement>;
+        canvas: HTMLFactory<HTMLCanvasElement>;
+        caption: HTMLFactory<HTMLElement>;
+        cite: HTMLFactory<HTMLElement>;
+        code: HTMLFactory<HTMLElement>;
+        col: HTMLFactory<HTMLTableColElement>;
+        colgroup: HTMLFactory<HTMLTableColElement>;
+        data: HTMLFactory<HTMLElement>;
+        datalist: HTMLFactory<HTMLDataListElement>;
+        dd: HTMLFactory<HTMLElement>;
+        del: HTMLFactory<HTMLElement>;
+        details: HTMLFactory<HTMLElement>;
+        dfn: HTMLFactory<HTMLElement>;
+        dialog: HTMLFactory<HTMLElement>;
+        div: HTMLFactory<HTMLDivElement>;
+        dl: HTMLFactory<HTMLDListElement>;
+        dt: HTMLFactory<HTMLElement>;
+        em: HTMLFactory<HTMLElement>;
+        embed: HTMLFactory<HTMLEmbedElement>;
+        fieldset: HTMLFactory<HTMLFieldSetElement>;
+        figcaption: HTMLFactory<HTMLElement>;
+        figure: HTMLFactory<HTMLElement>;
+        footer: HTMLFactory<HTMLElement>;
+        form: HTMLFactory<HTMLFormElement>;
+        h1: HTMLFactory<HTMLHeadingElement>;
+        h2: HTMLFactory<HTMLHeadingElement>;
+        h3: HTMLFactory<HTMLHeadingElement>;
+        h4: HTMLFactory<HTMLHeadingElement>;
+        h5: HTMLFactory<HTMLHeadingElement>;
+        h6: HTMLFactory<HTMLHeadingElement>;
+        head: HTMLFactory<HTMLHeadElement>;
+        header: HTMLFactory<HTMLElement>;
+        hgroup: HTMLFactory<HTMLElement>;
+        hr: HTMLFactory<HTMLHRElement>;
+        html: HTMLFactory<HTMLHtmlElement>;
+        i: HTMLFactory<HTMLElement>;
+        iframe: HTMLFactory<HTMLIFrameElement>;
+        img: HTMLFactory<HTMLImageElement>;
+        input: HTMLFactory<HTMLInputElement>;
+        ins: HTMLFactory<HTMLModElement>;
+        kbd: HTMLFactory<HTMLElement>;
+        keygen: HTMLFactory<HTMLElement>;
+        label: HTMLFactory<HTMLLabelElement>;
+        legend: HTMLFactory<HTMLLegendElement>;
+        li: HTMLFactory<HTMLLIElement>;
+        link: HTMLFactory<HTMLLinkElement>;
+        main: HTMLFactory<HTMLElement>;
+        map: HTMLFactory<HTMLMapElement>;
+        mark: HTMLFactory<HTMLElement>;
+        menu: HTMLFactory<HTMLElement>;
+        menuitem: HTMLFactory<HTMLElement>;
+        meta: HTMLFactory<HTMLMetaElement>;
+        meter: HTMLFactory<HTMLElement>;
+        nav: HTMLFactory<HTMLElement>;
+        noscript: HTMLFactory<HTMLElement>;
+        object: HTMLFactory<HTMLObjectElement>;
+        ol: HTMLFactory<HTMLOListElement>;
+        optgroup: HTMLFactory<HTMLOptGroupElement>;
+        option: HTMLFactory<HTMLOptionElement>;
+        output: HTMLFactory<HTMLElement>;
+        p: HTMLFactory<HTMLParagraphElement>;
+        param: HTMLFactory<HTMLParamElement>;
+        picture: HTMLFactory<HTMLElement>;
+        pre: HTMLFactory<HTMLPreElement>;
+        progress: HTMLFactory<HTMLProgressElement>;
+        q: HTMLFactory<HTMLQuoteElement>;
+        rp: HTMLFactory<HTMLElement>;
+        rt: HTMLFactory<HTMLElement>;
+        ruby: HTMLFactory<HTMLElement>;
+        s: HTMLFactory<HTMLElement>;
+        samp: HTMLFactory<HTMLElement>;
+        script: HTMLFactory<HTMLElement>;
+        section: HTMLFactory<HTMLElement>;
+        select: HTMLFactory<HTMLSelectElement>;
+        small: HTMLFactory<HTMLElement>;
+        source: HTMLFactory<HTMLSourceElement>;
+        span: HTMLFactory<HTMLSpanElement>;
+        strong: HTMLFactory<HTMLElement>;
+        style: HTMLFactory<HTMLStyleElement>;
+        sub: HTMLFactory<HTMLElement>;
+        summary: HTMLFactory<HTMLElement>;
+        sup: HTMLFactory<HTMLElement>;
+        table: HTMLFactory<HTMLTableElement>;
+        tbody: HTMLFactory<HTMLTableSectionElement>;
+        td: HTMLFactory<HTMLTableDataCellElement>;
+        textarea: HTMLFactory<HTMLTextAreaElement>;
+        tfoot: HTMLFactory<HTMLTableSectionElement>;
+        th: HTMLFactory<HTMLTableHeaderCellElement>;
+        thead: HTMLFactory<HTMLTableSectionElement>;
+        time: HTMLFactory<HTMLElement>;
+        title: HTMLFactory<HTMLTitleElement>;
+        tr: HTMLFactory<HTMLTableRowElement>;
+        track: HTMLFactory<HTMLTrackElement>;
+        u: HTMLFactory<HTMLElement>;
+        ul: HTMLFactory<HTMLUListElement>;
+        "var": HTMLFactory<HTMLElement>;
+        video: HTMLFactory<HTMLVideoElement>;
+        wbr: HTMLFactory<HTMLElement>;
 
         // SVG
         svg: SVGFactory;
@@ -2256,13 +2325,8 @@ declare namespace JSX {
     }
     interface ElementAttributesProperty { props: {}; }
 
-    interface IntrinsicAttributes {
-        key?: React.Key;
-    }
-
-    interface IntrinsicClassAttributes<T> {
-        ref?: React.Ref<T>;
-    }
+    interface IntrinsicAttributes extends React.Attributes { }
+    interface IntrinsicClassAttributes<T> extends React.ClassAttributes<T> { }
 
     interface IntrinsicElements {
         // HTML
diff --git a/sequelize/sequelize-tests.ts b/sequelize/sequelize-tests.ts
index 0e9adfe5f..ee5ff016b 100644
--- a/sequelize/sequelize-tests.ts
+++ b/sequelize/sequelize-tests.ts
@@ -1157,6 +1157,7 @@ new Sequelize( 'sequelize', null, null, {
 } );
 
 s.model( 'Project' );
+s.models['Project'];
 s.define( 'Project', {
     name : Sequelize.STRING
 } );
diff --git a/sequelize/sequelize.d.ts b/sequelize/sequelize.d.ts
index 3b42f52b2..353de8bac 100644
--- a/sequelize/sequelize.d.ts
+++ b/sequelize/sequelize.d.ts
@@ -5395,6 +5395,9 @@ declare module "sequelize" {
         }
 
         interface QueryOptionsTransactionRequired { }
+        interface ModelsHashInterface {
+            [name: string]: Model<any, any>;
+        }
 
         /**
          * This is the main class, the entry point to sequelize. To use it, you just need to
@@ -5415,6 +5418,11 @@ declare module "sequelize" {
              */
             Sequelize: SequelizeStatic;
 
+            /**
+             * Defined models.
+             */
+            models: ModelsHashInterface;
+
             /**
              * Returns the specified dialect.
              */
diff --git a/serve-static/serve-static-tests.ts b/serve-static/serve-static-tests.ts
index 9813794a6..7435ed3ab 100644
--- a/serve-static/serve-static-tests.ts
+++ b/serve-static/serve-static-tests.ts
@@ -1,4 +1,5 @@
 /// <reference path="serve-static.d.ts" />
+/// <reference path="../express/express.d.ts" />
 
 import * as express from 'express';
 import * as serveStatic from 'serve-static';
diff --git a/serve-static/serve-static.d.ts b/serve-static/serve-static.d.ts
index 29e5276cf..21c18ea14 100644
--- a/serve-static/serve-static.d.ts
+++ b/serve-static/serve-static.d.ts
@@ -10,11 +10,11 @@
 
  =============================================== */
 
-/// <reference path="../express/express.d.ts" />
+/// <reference path="../express-serve-static-core/express-serve-static-core.d.ts" />
 /// <reference path="../mime/mime.d.ts" />
 
 declare module "serve-static" {
-    import * as express from "express";
+    import * as express from "express-serve-static-core";
 
     /**
      * Create a new middleware function to serve files from within a given root directory.
diff --git a/signalr/signalr.d.ts b/signalr/signalr.d.ts
index 5f605eb5e..00bc88c15 100644
--- a/signalr/signalr.d.ts
+++ b/signalr/signalr.d.ts
@@ -169,12 +169,13 @@ declare namespace SignalR {
         protocol: string;
         host: string;
     }
-
+    
     interface Connection {
         clientProtocol: string;
         ajaxDataType: string;
         contentType: string;
         id: string;
+        json: JSON;
         logging: boolean;
         url: string;
         qs: string | Object;
diff --git a/soap/soap-tests.ts b/soap/soap-tests.ts
index e92257595..5229cfcf8 100644
--- a/soap/soap-tests.ts
+++ b/soap/soap-tests.ts
@@ -1,6 +1,7 @@
 /// <reference path="soap.d.ts" />
 
 import * as soap from 'soap';
+import * as events from 'events';
 
 const url = 'http://example.com/wsdl?wsdl';
 const wsdlOptions = { name: 'value' };
@@ -15,5 +16,8 @@ soap.createClient(url, wsdlOptions, function(err: any, client: soap.Client) {
     client['create']({ name: 'value' }, function(err, result) {
         // result is an object
     }, {});
+    client.on('request', function(obj: any) {
+        //obj is an object
+    });
 });
 
diff --git a/soap/soap.d.ts b/soap/soap.d.ts
index 2685953cc..36f50309b 100644
--- a/soap/soap.d.ts
+++ b/soap/soap.d.ts
@@ -3,11 +3,15 @@
 // Definitions by: Nicole Wang <https://github.com/nicoleWjie>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
 
+/// <reference path='../node/node.d.ts' />
+
 declare module 'soap' {
+    import * as events from 'events';
+
     class WSSecurity {
         constructor(username: string, password: string, options: any);
     }
-    interface Client {
+    interface Client extends events.EventEmitter {
         setSecurity(s: WSSecurity): void;
         [method: string]: (args: any, fn: (err: any, result: any) => void, options?: any) => void;
         addSoapHeader(headJSON: any): void;
diff --git a/svgjs/svgjs.d.ts b/svgjs/svgjs.d.ts
index c04f19536..4356d340e 100644
--- a/svgjs/svgjs.d.ts
+++ b/svgjs/svgjs.d.ts
@@ -7,8 +7,6 @@
 // TODO sets
 // TODO gradients
 
-declare var SVG:svgjs.Library;
-
 declare module svgjs {
 
     export interface LinkedHTMLElement extends HTMLElement {
@@ -272,6 +270,7 @@ declare module svgjs {
     }
 }
 
+declare var SVG:svgjs.Library;
 declare module "svg.js" {
-    export = svgjs
+    export = SVG
 }
diff --git a/tabtab/tabtab-tests.ts b/tabtab/tabtab-tests.ts
index 3204b7a05..69db6edbb 100644
--- a/tabtab/tabtab-tests.ts
+++ b/tabtab/tabtab-tests.ts
@@ -13,7 +13,7 @@ if (process.argv.slice(2)[0] === 'completion') {
         if (/^-\w?/.test(data.last)) return tabtab.log(['n', 'o', 'd', 'e'], data, '-');
         tabtab.log(['list', 'of', 'commands'], data);
 
-        child_process.exec('rake -H', function(err, stdout, stderr) {
+        child_process.exec('rake -H', {encoding: null as string}, function(err, stdout, stderr) {
             if (err) return;
             var decoder = new string_decoder.StringDecoder('utf8');
             var parsed = tabtab.parseOut(decoder.write(stdout));
@@ -21,7 +21,7 @@ if (process.argv.slice(2)[0] === 'completion') {
             if (/^-\w?/.test(data.last)) return tabtab.log(parsed.shorts, data, '-');
         });
 
-        child_process.exec('cake', function(err, stdout, stderr) {
+        child_process.exec('cake', {encoding: null as string}, function(err, stdout, stderr) {
             if (err) return;
             var decoder = new string_decoder.StringDecoder('utf8');
             var tasks = tabtab.parseTasks(decoder.write(stdout), 'cake');
diff --git a/threejs/three.d.ts b/threejs/three.d.ts
index c369e0d2b..eaa5b5f32 100644
--- a/threejs/three.d.ts
+++ b/threejs/three.d.ts
@@ -1631,8 +1631,11 @@ declare module THREE {
 
     export interface Intersection {
         distance: number;
+        distanceToRay: number;
         point: Vector3;
+        index: number;
         face: Face3;
+        faceIndex: number;
         object: Object3D;
     }
 
diff --git a/winrt/winrt.d.ts b/winrt/winrt.d.ts
index 687d7f83d..825e8186e 100644
--- a/winrt/winrt.d.ts
+++ b/winrt/winrt.d.ts
@@ -10017,7 +10017,7 @@ declare module Windows {
             removableDevices: Windows.Storage.StorageFolder;
             videosLibrary: Windows.Storage.StorageFolder;
         }
-        export class StorageFolder implements Windows.Storage.IStorageFolder, Windows.Storage.IStorageItem, Windows.Storage.Search.IStorageFolderQueryOperations, Windows.Storage.IStorageItemProperties {
+        export class StorageFolder implements Windows.Storage.IStorageFolder, Windows.Storage.IStorageFolder2, Windows.Storage.IStorageItem, Windows.Storage.Search.IStorageFolderQueryOperations, Windows.Storage.IStorageItemProperties {
             attributes: Windows.Storage.FileAttributes;
             dateCreated: Date;
             name: string;
@@ -10063,6 +10063,7 @@ declare module Windows {
             getThumbnailAsync(mode: Windows.Storage.FileProperties.ThumbnailMode, requestedSize: number): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
             getThumbnailAsync(mode: Windows.Storage.FileProperties.ThumbnailMode, requestedSize: number, options: Windows.Storage.FileProperties.ThumbnailOptions): Windows.Foundation.IAsyncOperation<Windows.Storage.FileProperties.StorageItemThumbnail>;
             static getFolderFromPathAsync(path: string): Windows.Foundation.IAsyncOperation<Windows.Storage.StorageFolder>;
+            tryGetItemAsync(name: string): Windows.Foundation.IAsyncOperation<IStorageItem>;
         }
         export class KnownFolders {
             static documentsLibrary: Windows.Storage.StorageFolder;
@@ -10212,6 +10213,9 @@ declare module Windows {
             getItemsAsync(): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem>>;
             getItemsAsync(startIndex: number, maxItemsToRetrieve: number): Windows.Foundation.IAsyncOperation<Windows.Foundation.Collections.IVectorView<Windows.Storage.IStorageItem>>;
         }
+        export interface IStorageFolder2 {
+            tryGetItemAsync(name: string): Windows.Foundation.IAsyncOperation<IStorageItem>;
+        }
         export interface IStorageFile extends Windows.Storage.IStorageItem, Windows.Storage.Streams.IRandomAccessStreamReference, Windows.Storage.Streams.IInputStreamReference {
             contentType: string;
             fileType: string;
diff --git a/winston/winston-tests.ts b/winston/winston-tests.ts
index 0147af581..46a00e4da 100644
--- a/winston/winston-tests.ts
+++ b/winston/winston-tests.ts
@@ -158,9 +158,9 @@ profiler.start = new Date();
 let testRewriter : winston.MetadataRewriter;
 testRewriter = function(level: string, msg: string, meta: any) {
     return meta;
-}
+};
 
-winston.addRewriter(testRewriter);
+logger.rewriters.push(testRewriter);
 /**
  * New Logger instances with transports tests:
  */
diff --git a/winston/winston.d.ts b/winston/winston.d.ts
index 0dc80a57c..2cc9f10d2 100644
--- a/winston/winston.d.ts
+++ b/winston/winston.d.ts
@@ -7,6 +7,10 @@
 
 /// <reference path="../node/node.d.ts" />
 
+///******************
+///  Winston v2.2.x
+///******************
+
 declare module "winston" {
   export var transports: Transports;
   export var Transport: TransportStatic;
@@ -15,6 +19,8 @@ declare module "winston" {
   export var loggers: ContainerInstance;
   export var defaultLogger: LoggerInstance;
 
+  export var exception: Exception;
+
   export var exitOnError: boolean;
   export var level: string;
 
@@ -46,17 +52,65 @@ declare module "winston" {
   export function addColors(target: any): any;
   export function setLevels(target: any): any;
   export function cli(): LoggerInstance;
-  export function addRewriter(rewriter: MetadataRewriter): void;
+  export function close(): void;
+
+  export interface ExceptionProcessInfo {
+    pid: number;
+    uid?: number;
+    gid?: number;
+    cwd: string;
+    execPath: string;
+    version: string;
+    argv: string;
+    memoryUsage: NodeJS.MemoryUsage;
+  }
+
+  export interface ExceptionOsInfo {
+    loadavg: [number, number, number];
+    uptime: number;
+  }
+
+  export interface ExceptionTrace {
+    column: number;
+    file: string;
+    "function": string;
+    line: number;
+    method: string;
+    native: boolean;
+  }
+
+  export interface ExceptionAllInfo {
+    date: Date;
+    process: ExceptionProcessInfo;
+    os: ExceptionOsInfo;
+    trace: Array<ExceptionTrace>;
+    stack: Array<string>;
+  }
+
+  export interface Exception {
+    getAllInfo(err: Error): ExceptionAllInfo;
+    getProcessInfo(): ExceptionProcessInfo;
+    getOsInfo(): ExceptionOsInfo;
+    getTrace(err: Error): Array<ExceptionTrace>;
+  }
 
   export interface MetadataRewriter {
     (level: string, msg: string, meta: any): any;
   }
 
+  export interface MetadataFilter {
+    (level: string, msg: string, meta: any): string | {msg: any; meta: any;};
+  }
+
   export interface LoggerStatic {
     new (options?: LoggerOptions): LoggerInstance;
   }
 
   export interface LoggerInstance extends NodeJS.EventEmitter {
+    rewriters: Array<MetadataRewriter>;
+    filters: Array<MetadataFilter>;
+    transports: Array<TransportInstance>;
+
     extend(target: any): LoggerInstance;
 
     log(level: string, msg: string, meta: any, callback?: (err: Error, level: string, msg: string, meta: any) => void): LoggerInstance;
@@ -81,7 +135,6 @@ declare module "winston" {
     handleExceptions(...transports: TransportInstance[]): void;
     unhandleExceptions(...transports: TransportInstance[]): void;
     add(transport: TransportInstance, options?: TransportOptions, created?: boolean): LoggerInstance;
-    addRewriter(rewriter: MetadataRewriter): void;
     clear(): void;
     remove(transport: TransportInstance): LoggerInstance;
     startTimer(): ProfileHandler;
@@ -129,6 +182,7 @@ declare module "winston" {
 
   export interface FileTransportInstance extends TransportInstance {
     new (options?: FileTransportOptions): FileTransportInstance;
+    close(): void;
   }
 
   export interface HttpTransportInstance extends TransportInstance {
@@ -269,10 +323,7 @@ declare module "winston" {
     start?: number;
     from?: Date;
     until?: Date;
-    /**
-     * 'asc' or 'desc'
-     */
-    order?: string;
+    order?: "asc" | "desc";
     fields: any;
   }
 
diff --git a/xdomain/xdomain-tests.ts b/xdomain/xdomain-tests.ts
new file mode 100644
index 000000000..303fa15fe
--- /dev/null
+++ b/xdomain/xdomain-tests.ts
@@ -0,0 +1,14 @@
+/// <reference path="./xdomain.d.ts" />
+
+xdomain.masters({
+  'http://abc.example.com': '/api/*'
+});
+
+xdomain.slaves({
+  "http://xyz.example.com": "/proxy.html"
+});
+
+xdomain.debug = true;
+xdomain.on("log", (msg) => console.log(msg));
+xdomain.on("timeout", () => console.log("timeout"));
+xdomain.cookies.master = "MASTER";
diff --git a/xdomain/xdomain.d.ts b/xdomain/xdomain.d.ts
new file mode 100644
index 000000000..dddab6f37
--- /dev/null
+++ b/xdomain/xdomain.d.ts
@@ -0,0 +1,52 @@
+// Type definitions for xdomain v0.7.5
+// Project: http://jpillora.com/xdomain/
+// Definitions by: Dan Chao <http://dchao.co/>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+declare interface XDomainCookies {
+  master: string;
+  slave: string;
+}
+
+declare interface IXDomain {
+  /**
+   * Will initialize as a master
+   *
+   * Each of the slaves must be defined as: origin: proxy file
+   *
+   * The slaves object is used as a list slaves to force one proxy file per origin.
+   * @param slaveObj
+   */
+  slaves (slaveObj: Object): void;
+  /**
+   * Will initialize as a slave
+   *
+   * Each of the masters must be defined as: origin: path
+   *
+   * origin and path are converted to a regular expression by escaping all non-alphanumeric chars, then converting * into .* and finally wrapping it with ^ and $. path can also be a RegExp literal.
+   *
+   * Requests that do not match both the origin and the path regular expressions will be blocked.
+   * @param masterObj
+   */
+  masters (masterObj: Object): void;
+  origin: string;
+  /**
+   * When true, XDomain will log actions to console
+   */
+  debug: boolean;
+  /**
+   * event may be log, warn or timeout. When listening for log and warn events, handler with contain the message as
+   * the first parameter. The timeout event fires when an iframe exeeds the xdomain.timeout time limit.
+   * @param event
+   * @param handler
+   */
+  on (event: "log"|"warn"|"timeout", handler: (message?: string) => any): void;
+  cookies: XDomainCookies;
+}
+
+declare var xdomain: IXDomain;
+
+declare module "xdomain" {
+  export const xdomain: IXDomain;
+}
diff --git a/xrm/parature.d.ts b/xrm/parature.d.ts
index 030c97b68..009f27b4b 100644
--- a/xrm/parature.d.ts
+++ b/xrm/parature.d.ts
@@ -12,7 +12,7 @@ declare module Xrm.Page
      *
      * @sa  Control
      */
-    export interface KbSearchControl extends Control
+    export interface KbSearchControl extends Xrm.Page.Control
     {
         /**
          * Use this method to add an event handler to the OnResultOpened event.
diff --git a/xrm/xrm-tests.ts b/xrm/xrm-tests.ts
index 50fd36955..4dfb8e409 100644
--- a/xrm/xrm-tests.ts
+++ b/xrm/xrm-tests.ts
@@ -1,6 +1,11 @@
 /// <reference path="xrm.d.ts" />
 /// <reference path="parature.d.ts" />
 
+/// Demonstrate usage in the browser's window object
+
+window.Xrm.Utility.alertDialog( "message", () => {} );
+parent.Xrm.Page.context.getOrgLcid();
+
 /// Demonstrate clientglobalcontext.d.ts 
 
 function _getContext()
@@ -91,7 +96,7 @@ Xrm.Page.data.entity.addOnSave(( context ) =>
 {
     var eventArgs = context.getEventArgs();
 
-    if ( eventArgs.getSaveMode() === Xrm.Page.SaveMode.AutoSave || eventArgs.getSaveMode() === Xrm.Page.SaveMode.SaveAndClose )
+    if ( eventArgs.getSaveMode() === XrmEnum.SaveMode.AutoSave || eventArgs.getSaveMode() === XrmEnum.SaveMode.SaveAndClose )
         eventArgs.preventDefault();
 });
 
diff --git a/xrm/xrm.d.ts b/xrm/xrm.d.ts
index a2f7c515b..716b09799 100644
--- a/xrm/xrm.d.ts
+++ b/xrm/xrm.d.ts
@@ -1,10 +1,215 @@
-// Type definitions for Microsoft Dynamics xRM API v7.1
+// Type definitions for Microsoft Dynamics xRM API v7.1
 // Project: http://www.microsoft.com/en-us/download/details.aspx?id=44567
-// Definitions by: David Berry <https://github.com/6ix4our/>, Matt Ngan <https://github.com/mattngan/>
+// Definitions by: David Berry <https://github.com/6ix4our/>, Matt Ngan <https://github.com/mattngan/>, Markus Mauch <https://github.com/markusmauch/>
 // Definitions: https://github.com/borisyankov/DefinitelyTyped
 
+declare var Xrm: Xrm.XrmStatic;
+declare function GetGlobalContext(): Xrm.Context; 
+
+interface Window
+{
+    Xrm: Xrm.XrmStatic;
+    GetGlobalContext(): Xrm.Context;
+}
+
 declare module Xrm
 {
+    /**
+     * Static xRM object.
+     */
+    export interface XrmStatic
+    {
+        /**
+         * Provides a namespace container for the context, data and ui objects.
+         */
+        Page: {
+            /**
+             * Provides methods to retrieve information specific to an organization, a user, or parameters passed to a page.
+             */
+            context: Context;
+
+            /**
+             * Provides methods to work with the form.
+             */
+            data: Data;
+
+            /**
+             * Contains properties and methods to retrieve information about the user interface as well as collections for several subcomponents of the form.
+             */
+            ui: Ui;
+
+            /**
+             * Gets all attributes.
+             *
+             * @return  An array of attributes.
+             */
+            getAttribute(): Page.Attribute[];
+
+            /**
+             * Gets an attribute matching attributeName.
+             *
+             * @tparam  T   An Attribute type.
+             * @param   {string}    attributeName   Name of the attribute.
+             *
+             * @return  The attribute.
+             */
+            getAttribute<T extends Page.Attribute>( attributeName: string ): T;
+
+            /**
+             * Gets an attribute matching attributeName.
+             *
+             * @param   {string}    attributeName   Name of the attribute.
+             *
+             * @return  The attribute.
+             */
+            getAttribute( attributeName: string ): Page.Attribute;
+
+            /**
+             * Gets an attribute by index.
+             *
+             * @param   {number}    index   The attribute index.
+             *
+             * @return  The attribute.
+             */
+            getAttribute( index: number ): Page.Attribute;
+
+            /**
+             * Gets an attribute.
+             *
+             * @param   {Collection.MatchingDelegate{Attribute}}    delegateFunction    A matching delegate function
+             *
+             * @return  An array of attribute.
+             */
+            getAttribute( delegateFunction: Collection.MatchingDelegate<Page.Attribute> ): Page.Attribute[];
+
+            /**
+             * Gets all controls.
+             *
+             * @return  An array of controls.
+             */
+            getControl(): Page.Control[];
+
+            /**
+             * Gets a control matching controlName.
+             *
+             * @tparam  T   A Control type
+             * @param   {string}    controlName Name of the control.
+             *
+             * @return  The control.
+             */
+            getControl<T extends Page.Control>( controlName: string ): T;
+
+            /**
+             * Gets a control matching controlName.
+             *
+             * @param   {string}    controlName Name of the control.
+             *
+             * @return  The control.
+             */
+            getControl( controlName: string ): Page.Control;
+
+            /**
+             * Gets a control by index.
+             *
+             * @param   {number}    index   The control index.
+             *
+             * @return  The control.
+             */
+            getControl( index: number ): Page.Control;
+
+            /**
+             * Gets a control.
+             *
+             * @param   {Collection.MatchingDelegate{Control}}  delegateFunction    A matching delegate function.
+             *
+             * @return  An array of control.
+             */
+            getControl( delegateFunction: Collection.MatchingDelegate<Page.Control> ): Page.Control[];
+        }
+
+        /**
+         * Provides a container for useful functions not directly related to the current page.
+         */
+        Utility: {
+            /**
+             * Displays an alert dialog, with an "OK" button.
+             *
+             * @param   {string}        message         The message.
+             * @param   {function()}    onCloseCallback The "OK" callback.
+             */
+            alertDialog( message: string, onCloseCallback: () => void ): void;
+
+            /**
+             * Displays a confirmation dialog, with "OK" and "Cancel" buttons.
+             *
+             * @param   {string}        message             The message.
+             * @param   {function()}    yesCloseCallback    The "OK" callback.
+             * @param   {function()}    noCloseCallback     The "Cancel" callback.
+             */
+            confirmDialog( message: string, yesCloseCallback: () => void, noCloseCallback: () => void ): void;
+
+            /**
+             * Query if 'entityType' is an Activity entity.
+             *
+             * @param   {string}    entityType  Type of the entity.
+             *
+             * @return  true if the entity is an Activity, false if not.
+             */
+            isActivityType( entityType: string ): boolean;
+
+            /**
+             * Opens quick create.
+             *
+             * @param   {Function}  callback                    The function that will be called when a record is created. This
+             *                                                  function is passed a LookupValue object as a parameter.
+             * @param   {string}    entityLogicalName           The logical name of the entity to create.
+             * @param   {Page.LookupValue}  createFromEntity    (Optional) Designates a record that will provide default values
+             *                                                  based on mapped attribute values.
+             * @param   {OpenParameters}    parameters          (Optional) A dictionary object that passes extra query string
+             *                                                  parameters to the form. Invalid query string parameters will cause an
+             *                                                  error.
+             */
+            openQuickCreate(
+                callback: ( recordReference: Page.LookupValue ) => void,
+                entityLogicalName: string,
+                createFromEntity?: Page.LookupValue,
+                parameters?: Utility.OpenParameters ): void;
+
+            /**
+             * Opens an entity form.
+             *
+             * @param   {string}    name                The entity's logical name.
+             * @param   {string}    id                  (Optional) The unique identifier for the record.
+             * @param   {FormParameters}    parameters  (Optional) A dictionary object that passes extra query string parameters to the form.
+             * @param   {WindowOptions} windowOptions   (Optional) Options for controlling the window.
+             */
+            openEntityForm( name: string, id?: string, parameters?: Utility.FormOpenParameters, windowOptions?: Utility.WindowOptions ): void;
+
+            /**
+             * Opens an HTML Web Resource in a new browser window.
+             *
+             * @param   {string}    webResourceName Name of the HTML web resource. Can be used to pass URL
+             *                                      parameters.  See Remarks.
+             * @param   {string}    webResourceData (Optional) Data to pass into the Web Resource's data parameter.
+             *                                                 It is advised to use encodeURIcomponent() to encode the value.
+             * @param   {number}    width           (Optional) The width of the new window.
+             * @param   {number}    height          (Optional) The height of the new window.
+             *
+             * @return  A Window reference, containing the opened Web Resource.
+             *
+             * @remarks This function will not work with Microsoft Dynamics CRM for tablets.
+             *          Valid WebResource URL Parameters:   typename
+             *                                              type
+             *                                              id
+             *                                              orgname
+             *                                              userlcid
+             *                                              data (identical to this method's webResourceData parameter)
+             *                                              formid
+             */
+            openWebResource( webResourceName: string, webResourceData?: string, width?: number, height?: number ): Window;
+        }
+    }
+
     /**
      * Interface for the client context.
      */
@@ -28,7 +233,7 @@ declare module Xrm
     /**
      * Interface for the xRM application context.
      */
-    export interface Context
+    interface Context
     {
         /**
          * The client's context instance.
@@ -139,6 +344,170 @@ declare module Xrm
         prependOrgName( sPath: string ): string;
     }
 
+    /**
+     * Interface for the Xrm.Page.data object.
+     */
+    export interface Data
+    {
+        /**
+         * Asynchronously refreshes data on the form, without reloading the page.
+         *
+         * @param   {boolean}   save    true to save the record, after the refresh.
+         *
+         * @return  An Async.XrmPromise.
+         */
+        refresh( save: boolean ): Async.XrmPromise;
+
+        /**
+         * Asynchronously saves the record.
+         *
+         * @return  An Async.XrmPromise.
+         */
+        save(): Async.XrmPromise;
+
+        /**
+         * The record context of the form.
+         */
+        entity: Page.Entity;
+
+        /**
+         * The process API for Xrm.Page.data.
+         *
+         * @remarks This member may be undefined when Process Flows are not used by the current entity.
+         */
+        process: Page.data.ProcessManager;
+    }
+
+    /**
+     * Interface for the Xrm.Page.ui object.
+     */
+    export interface Ui
+    {
+        /**
+         * Clears the form notification described by uniqueId.
+         *
+         * @param   {string}    uniqueId    Unique identifier.
+         *
+         * @return  true if it succeeds, otherwise false.
+         */
+        clearFormNotification( uniqueId: string ): boolean;
+
+        /**
+         * Closes the form.
+         */
+        close(): void;
+
+        /**
+         * Gets form type.
+         *
+         * @return  The form type.
+         *
+         * @remarks     Values returned are: 0  Undefined
+         *                                   1  Create
+         *                                   2  Update
+         *                                   3  Read Only
+         *                                   4  Disabled
+         *                                   6  Bulk Edit
+         *              Deprecated values are 5 (Quick Create), and 11 (Read Optimized)
+         */
+        getFormType(): XrmEnum.FormType;
+
+        /**
+         * Gets view port height.
+         *
+         * @return  The view port height, in pixels.
+         *
+         * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
+         */
+        getViewPortHeight(): number;
+
+        /**
+         * Gets view port width.
+         *
+         * @return  The view port width, in pixels.
+         *
+         * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
+         */
+        getViewPortWidth(): number;
+
+        /**
+         * Re-evaluates the ribbon's configured EnableRules
+         *
+         * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
+         */
+        refreshRibbon(): void;
+
+        /**
+         * Sets a form-level notification.
+         *
+         * @param   {string}    message     The message.
+         * @param   {"ERROR"}   level       An error message.
+         * @param   {string}    uniqueId    A unique identifier for the message.
+         *
+         * @return  true if it succeeds, false if it fails.
+         */
+        setFormNotification( message: string, level: "ERROR", uniqueId: string ): boolean;
+
+        /**
+         * Sets a form-level notification.
+         *
+         * @param   {string}    message     The message.
+         * @param   {"WARNING"} level       A warning message.
+         * @param   {string}    uniqueId    A unique identifier for the message.
+         *
+         * @return  true if it succeeds, false if it fails.
+         */
+        setFormNotification( message: string, level: "WARNING", uniqueId: string ): boolean;
+
+        /**
+         * Sets a form-level notification.
+         *
+         * @param   {string}    message     The message.
+         * @param   {"INFO"}    level       An informational message.
+         * @param   {string}    uniqueId    A unique identifier for the message.
+         *
+         * @return  true if it succeeds, false if it fails.
+         */
+        setFormNotification( message: string, level: "INFO", uniqueId: string ): boolean;
+
+        /**
+         * Sets a form-level notification.
+         *
+         * @param   {string}    message     The message.
+         * @param   {string}    level       The level, as either "ERROR", "WARNING", or "INFO".
+         * @param   {string}    uniqueId    A unique identifier for the message.
+         *
+         * @return  true if it succeeds, otherwise false.
+         */
+        setFormNotification( message: string, level: string, uniqueId: string ): boolean;
+
+        process: Page.data.ProcessManager;
+
+        /**
+         * A reference to the collection of controls on the form.
+         */
+        controls: Collection.ItemCollection<Page.Control>;
+
+        /**
+         * The form selector API.
+         *
+         * @remarks This API does not exist with Microsoft Dynamics CRM for tablets.
+         */
+        formSelector: Page.FormSelector;
+
+        /**
+         * The navigation API.
+         *
+         * @remarks This API does not exist with Microsoft Dynamics CRM for tablets.
+         */
+        navigation: Page.Navigation;
+
+        /**
+         * A reference to the collection of tabs on the form.
+         */
+        tabs: Collection.ItemCollection<Page.Tab>;
+    }
+
     /**
      *  A definition module for asynchronous interface declarations.
      */
@@ -277,63 +646,6 @@ declare module Xrm
      */
     export module Page
     {
-        /**
-         * Enumeration of entity form states/types.
-         */
-        export const enum FormType
-        {
-            Undefined = 0,
-            Create = 1,
-            Update = 2,
-            ReadOnly = 3,
-            Disabled = 4,
-            BulkEdit = 6
-        }
-
-        /**
-         * Enumeration of entity form save modes.
-         */
-        export const enum SaveMode
-        {
-            Save = 1,
-            SaveAndClose = 2,
-            SaveAndNew = 59,
-            AutoSave = 70,
-            SaveAsCompleted = 58,
-            Deactivate = 5,
-            Reactivate = 6,
-            Assign = 47,
-            Send = 7,
-            Qualify = 16,
-            Disqualify = 15
-        }
-
-        /**
-         * Enumeration of stage categories.
-         */
-        export const enum StageCategory
-        {
-            Qualify = 0,
-            Develop = 1,
-            Propose = 2,
-            Close = 3,
-            Identify = 4,
-            Research = 5,
-            Resolve = 6
-        }
-
-        /**
-         * Enumeration of grid control context resolutions.
-         */
-        export const enum GridControlContext
-        {
-            Unknown = 0,
-            RibbonContextForm = 1,
-            RibbonContextListing = 2,
-            FormContextUnrelated = 3,
-            FormContextRelated = 4
-        }
-
         /**
          * Interface for a CRM Business Process Flow instance.
          */
@@ -381,7 +693,7 @@ declare module Xrm
              *
              * @return  The stage category.
              */
-            getCategory(): { getValue(): StageCategory };
+            getCategory(): { getValue(): XrmEnum.StageCategory };
 
             /**
              * Returns the logical name of the entity associated with the stage.
@@ -486,7 +798,7 @@ declare module Xrm
              *
              * @return  The event source.
              */
-            getEventSource(): Xrm.Page.Attribute | Xrm.Page.Entity;
+            getEventSource(): Page.Attribute | Page.Entity;
 
             /**
              * Gets the shared variable with the specified key.
@@ -1164,7 +1476,7 @@ declare module Xrm
              *                               16     Qualify (Lead)
              *                               15     Disqualify (Lead)
              */
-            getSaveMode(): SaveMode;
+            getSaveMode(): XrmEnum.SaveMode;
 
             /**
              * Returns a boolean value to indicate if the record's save has been prevented.
@@ -1302,34 +1614,6 @@ declare module Xrm
              * Represents a key-value pair, where the key is the Process Flow's ID, and the value is the name thereof.
              */
             export type ProcessDictionary = { [index: string]: string };
-
-            /**
-             * Asynchronously refreshes data on the form, without reloading the page.
-             *
-             * @param   {boolean}   save    true to save the record, after the refresh.
-             *
-             * @return  An Async.XrmPromise.
-             */
-            export function refresh( save: boolean ): Async.XrmPromise;
-
-            /**
-             * Asynchronously saves the record.
-             *
-             * @return  An Async.XrmPromise.
-             */
-            export function save(): Async.XrmPromise;
-
-            /**
-             * The record context of the form.
-             */
-            export var entity: Entity;
-
-            /**
-             * The process API for Xrm.Page.data.
-             *
-             * @remarks This member may be undefined when Process Flows are not used by the current entity.
-             */
-            export var process: ProcessManager;
         }
 
         /**
@@ -1612,7 +1896,7 @@ declare module Xrm
              *
              * @return  The context type.
              */
-            getContextType(): GridControlContext;
+            getContextType(): XrmEnum.GridControlContext;
 
             /**
              * Use this method to get the logical name of the entity data displayed in the grid.
@@ -1767,7 +2051,7 @@ declare module Xrm
              *
              * @return  The parent.
              */
-            getParent(): typeof ui;
+            getParent(): Ui;
 
             /**
              * Sets display state of the tab.
@@ -1996,130 +2280,6 @@ declare module Xrm
                  */
                 getEntityReference(): LookupValue;
             }
-
-            /**
-             * Clears the form notification described by uniqueId.
-             *
-             * @param   {string}    uniqueId    Unique identifier.
-             *
-             * @return  true if it succeeds, otherwise false.
-             */
-            export function clearFormNotification( uniqueId: string ): boolean;
-
-            /**
-             * Closes the form.
-             */
-            export function close(): void;
-
-            /**
-             * Gets form type.
-             *
-             * @return  The form type.
-             *
-             * @remarks     Values returned are: 0  Undefined
-             *                                   1  Create
-             *                                   2  Update
-             *                                   3  Read Only
-             *                                   4  Disabled
-             *                                   6  Bulk Edit
-             *              Deprecated values are 5 (Quick Create), and 11 (Read Optimized)
-             */
-            export function getFormType(): FormType;
-
-            /**
-             * Gets view port height.
-             *
-             * @return  The view port height, in pixels.
-             *
-             * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
-             */
-            export function getViewPortHeight(): number;
-
-            /**
-             * Gets view port width.
-             *
-             * @return  The view port width, in pixels.
-             *
-             * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
-             */
-            export function getViewPortWidth(): number;
-
-            /**
-             * Re-evaluates the ribbon's configured EnableRules
-             *
-             * @remarks This method does not work with Microsoft Dynamics CRM for tablets.
-             */
-            export function refreshRibbon(): void;
-
-            /**
-             * Sets a form-level notification.
-             *
-             * @param   {string}    message     The message.
-             * @param   {"ERROR"}   level       An error message.
-             * @param   {string}    uniqueId    A unique identifier for the message.
-             *
-             * @return  true if it succeeds, false if it fails.
-             */
-            export function setFormNotification( message: string, level: "ERROR", uniqueId: string ): boolean;
-
-            /**
-             * Sets a form-level notification.
-             *
-             * @param   {string}    message     The message.
-             * @param   {"WARNING"} level       A warning message.
-             * @param   {string}    uniqueId    A unique identifier for the message.
-             *
-             * @return  true if it succeeds, false if it fails.
-             */
-            export function setFormNotification( message: string, level: "WARNING", uniqueId: string ): boolean;
-
-            /**
-             * Sets a form-level notification.
-             *
-             * @param   {string}    message     The message.
-             * @param   {"INFO"}    level       An informational message.
-             * @param   {string}    uniqueId    A unique identifier for the message.
-             *
-             * @return  true if it succeeds, false if it fails.
-             */
-            export function setFormNotification( message: string, level: "INFO", uniqueId: string ): boolean;
-
-            /**
-             * Sets a form-level notification.
-             *
-             * @param   {string}    message     The message.
-             * @param   {string}    level       The level, as either "ERROR", "WARNING", or "INFO".
-             * @param   {string}    uniqueId    A unique identifier for the message.
-             *
-             * @return  true if it succeeds, otherwise false.
-             */
-            export function setFormNotification( message: string, level: string, uniqueId: string ): boolean;
-
-            export var process: ProcessManager;
-
-            /**
-             * A reference to the collection of controls on the form.
-             */
-            export var controls: Collection.ItemCollection<Control>;
-
-            /**
-             * The form selector API.
-             *
-             * @remarks This API does not exist with Microsoft Dynamics CRM for tablets.
-             */
-            export var formSelector: FormSelector;
-
-            /**
-             * The navigation API.
-             *
-             * @remarks This API does not exist with Microsoft Dynamics CRM for tablets.
-             */
-            export var navigation: Navigation;
-
-            /**
-             * A reference to the collection of tabs on the form.
-             */
-            export var tabs: Collection.ItemCollection<Tab>;
         }
 
         /**
@@ -2193,99 +2353,6 @@ declare module Xrm
              */
             items: Collection.ItemCollection<FormItem>;
         }
-
-        /**
-         * A reference to the xRM application context.
-         */
-        export var context: Context;
-
-        /**
-         * Gets all attributes.
-         *
-         * @return  An array of attributes.
-         */
-        export function getAttribute(): Attribute[];
-
-        /**
-         * Gets an attribute matching attributeName.
-         *
-         * @tparam  T   An Attribute type.
-         * @param   {string}    attributeName   Name of the attribute.
-         *
-         * @return  The attribute.
-         */
-        export function getAttribute<T extends Attribute>( attributeName: string ): T;
-
-        /**
-         * Gets an attribute matching attributeName.
-         *
-         * @param   {string}    attributeName   Name of the attribute.
-         *
-         * @return  The attribute.
-         */
-        export function getAttribute( attributeName: string ): Attribute;
-
-        /**
-         * Gets an attribute by index.
-         *
-         * @param   {number}    index   The attribute index.
-         *
-         * @return  The attribute.
-         */
-        export function getAttribute( index: number ): Attribute;
-
-        /**
-         * Gets an attribute.
-         *
-         * @param   {Collection.MatchingDelegate{Attribute}}    delegateFunction    A matching delegate function
-         *
-         * @return  An array of attribute.
-         */
-        export function getAttribute( delegateFunction: Collection.MatchingDelegate<Attribute> ): Attribute[];
-
-        /**
-         * Gets all controls.
-         *
-         * @return  An array of controls.
-         */
-        export function getControl(): Control[];
-
-        /**
-         * Gets a control matching controlName.
-         *
-         * @tparam  T   A Control type
-         * @param   {string}    controlName Name of the control.
-         *
-         * @return  The control.
-         */
-        export function getControl<T extends Control>( controlName: string ): T;
-
-        /**
-         * Gets a control matching controlName.
-         *
-         * @param   {string}    controlName Name of the control.
-         *
-         * @return  The control.
-         */
-        export function getControl( controlName: string ): Control;
-
-        /**
-         * Gets a control by index.
-         *
-         * @param   {number}    index   The control index.
-         *
-         * @return  The control.
-         */
-        export function getControl( index: number ): Control;
-
-        /**
-         * Gets a control.
-         *
-         * @param   {Collection.MatchingDelegate{Control}}  delegateFunction    A matching delegate function.
-         *
-         * @return  An array of control.
-         */
-        export function getControl( delegateFunction: Collection.MatchingDelegate<Control> ): Control[];
     }
 
     /**
@@ -2295,15 +2362,6 @@ declare module Xrm
      */
     export module Url
     {
-        /**
-         * An enumeration for view types.
-         */
-        export const enum ViewType
-        {
-            SystemView = 1039,
-            UserView = 4230
-        }
-
         /**
          * Interface for defining parameters on a request to open a form with main.aspx (as with
          * window.open). Useful for parsing the keys and values into a string of the format:
@@ -2376,7 +2434,7 @@ declare module Xrm
              * @remarks  Accepted values are:    1039    System View
              *                                   4230    User View.
              */
-            viewtype: ViewType;
+            viewtype: XrmEnum.ViewType;
 
             /**
              * Controls whether the command bar is displayed.
@@ -2506,89 +2564,74 @@ declare module Xrm
              */
             openInNewWindow: boolean;
         }
-
-        /**
-         * Displays an alert dialog, with an "OK" button.
-         *
-         * @param   {string}        message         The message.
-         * @param   {function()}    onCloseCallback The "OK" callback.
-         */
-        export function alertDialog( message: string, onCloseCallback: () => void ): void;
-
-        /**
-         * Displays a confirmation dialog, with "OK" and "Cancel" buttons.
-         *
-         * @param   {string}        message             The message.
-         * @param   {function()}    yesCloseCallback    The "OK" callback.
-         * @param   {function()}    noCloseCallback     The "Cancel" callback.
-         */
-        export function confirmDialog( message: string, yesCloseCallback: () => void, noCloseCallback: () => void ): void;
-
-        /**
-         * Query if 'entityType' is an Activity entity.
-         *
-         * @param   {string}    entityType  Type of the entity.
-         *
-         * @return  true if the entity is an Activity, false if not.
-         */
-        export function isActivityType( entityType: string ): boolean;
-
-        /**
-         * Opens an entity form.
-         *
-         * @param   {string}    name                The entity's logical name.
-         * @param   {string}    id                  (Optional) The unique identifier for the record.
-         * @param   {FormParameters}    parameters  (Optional) A dictionary object that passes extra query string parameters to the form.
-         * @param   {WindowOptions} windowOptions   (Optional) Options for controlling the window.
-         */
-        export function openEntityForm( name: string, id?: string, parameters?: FormOpenParameters, windowOptions?: WindowOptions ): void;
-
-        /**
-         * Opens quick create.
-         *
-         * @param   {Function}  callback                    The function that will be called when a record is created. This
-         *                                                  function is passed a LookupValue object as a parameter.
-         * @param   {string}    entityLogicalName           The logical name of the entity to create.
-         * @param   {Page.LookupValue}  createFromEntity    (Optional) Designates a record that will provide default values
-         *                                                  based on mapped attribute values.
-         * @param   {OpenParameters}    parameters          (Optional) A dictionary object that passes extra query string
-         *                                                  parameters to the form. Invalid query string parameters will cause an
-         *                                                  error.
-         */
-        export function openQuickCreate( callback: ( recordReference: Page.LookupValue ) => void,
-            entityLogicalName: string,
-            createFromEntity?: Page.LookupValue,
-            parameters?: OpenParameters ): void;
-
-        /**
-         * Opens an HTML Web Resource in a new browser window.
-         *
-         * @param   {string}    webResourceName Name of the HTML web resource. Can be used to pass URL
-         *                                      parameters.  See Remarks.
-         * @param   {string}    webResourceData (Optional) Data to pass into the Web Resource's data parameter.
-         *                                                 It is advised to use encodeURIcomponent() to encode the value.
-         * @param   {number}    width           (Optional) The width of the new window.
-         * @param   {number}    height          (Optional) The height of the new window.
-         *
-         * @return  A Window reference, containing the opened Web Resource.
-         *
-         * @remarks This function will not work with Microsoft Dynamics CRM for tablets.
-         *          Valid WebResource URL Parameters:   typename
-         *                                              type
-         *                                              id
-         *                                              orgname
-         *                                              userlcid
-         *                                              data (identical to this method's webResourceData parameter)
-         *                                              formid
-         */
-        export function openWebResource( webResourceName: string, webResourceData?: string, width?: number, height?: number ): Window;
     }
 }
 
-/**
- * Gets the xRM application context, for HTML web resources, included by ClientGlobalContext.js.aspx
- * @returns {Xrm.Context}   The application context for the user's current session.
- * @remarks The ClientGlobalContext.js.aspx page will include some global event handlers. These event handlers will
- *          cancel the onselectstart, contextmenu, and ondragstart events.
- */
-declare function GetGlobalContext(): Xrm.Context;
+declare module XrmEnum
+{
+    /**
+     * Enumeration of entity form states/types.
+     */
+    export const enum FormType
+    {
+        Undefined = 0,
+        Create = 1,
+        Update = 2,
+        ReadOnly = 3,
+        Disabled = 4,
+        BulkEdit = 6
+    }
+
+    /**
+     * Enumeration of entity form save modes.
+     */
+    export const enum SaveMode
+    {
+        Save = 1,
+        SaveAndClose = 2,
+        SaveAndNew = 59,
+        AutoSave = 70,
+        SaveAsCompleted = 58,
+        Deactivate = 5,
+        Reactivate = 6,
+        Assign = 47,
+        Send = 7,
+        Qualify = 16,
+        Disqualify = 15
+    }
+
+    /**
+     * Enumeration of stage categories.
+     */
+    export const enum StageCategory
+    {
+        Qualify = 0,
+        Develop = 1,
+        Propose = 2,
+        Close = 3,
+        Identify = 4,
+        Research = 5,
+        Resolve = 6
+    }
+
+    /**
+     * Enumeration of grid control context resolutions.
+     */
+    export const enum GridControlContext
+    {
+        Unknown = 0,
+        RibbonContextForm = 1,
+        RibbonContextListing = 2,
+        FormContextUnrelated = 3,
+        FormContextRelated = 4
+    }
+
+    /**
+     * An enumeration for view types.
+     */
+    export const enum ViewType
+    {
+        SystemView = 1039,
+        UserView = 4230
+    }
+}
\ No newline at end of file