diff --git a/types/prosemirror-collab/index.d.ts b/types/prosemirror-collab/index.d.ts
index 658dc9e00d..039f9d3b8f 100644
--- a/types/prosemirror-collab/index.d.ts
+++ b/types/prosemirror-collab/index.d.ts
@@ -3,14 +3,14 @@
 // Definitions by: Bradley Ayers <https://github.com/bradleyayers>
 //                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 import { Plugin } from 'prosemirror-state';
 import { EditorState } from 'prosemirror-state';
 import { Step } from 'prosemirror-transform';
 import { Transaction } from 'prosemirror-state';
 
-export function collab(config?: { version?: number, clientID?: number | string }): Plugin;
+export function collab<T>(config?: { version?: number, clientID?: number | string }): Plugin<T>;
 export function receiveTransaction(state: EditorState, steps: Step[], clientIDs: Array<number | string>): Transaction;
 export function sendableSteps(state: EditorState): { version: number, steps: Step[], clientID: number | string, origins: Transaction[] } | null;
 export function getVersion(state: EditorState): number;
diff --git a/types/prosemirror-commands/index.d.ts b/types/prosemirror-commands/index.d.ts
index d29dc92068..9309a0522f 100644
--- a/types/prosemirror-commands/index.d.ts
+++ b/types/prosemirror-commands/index.d.ts
@@ -3,14 +3,11 @@
 // Definitions by: Bradley Ayers <https://github.com/bradleyayers>
 //                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.2
 
-import { EditorState } from 'prosemirror-state';
-import { Transaction } from 'prosemirror-state';
+import { MarkType, Node, NodeType } from 'prosemirror-model';
+import { EditorState, Transaction } from 'prosemirror-state';
 import { EditorView } from 'prosemirror-view';
-import { NodeType } from 'prosemirror-model';
-import { MarkType } from 'prosemirror-model';
-import { ProsemirrorNode as Node } from 'prosemirror-model';
 
 export function deleteSelection(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 export function joinBackward(state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView): boolean;
@@ -26,10 +23,11 @@ export function splitBlock(state: EditorState, dispatch?: (tr: Transaction) => v
 export function splitBlockKeepMarks(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 export function selectParentNode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 export function selectAll(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
-export function wrapIn(nodeType: NodeType, attrs?: { [key: string]: any }): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
-export function setBlockType(nodeType: NodeType, attrs?: { [key: string]: any }): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
-export function toggleMark(markType: MarkType, attrs?: { [key: string]: any }): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
-export function autoJoin(command: (state: EditorState, _1?: (tr: Transaction) => void) => boolean,
-                         isJoinable: ((before: Node, after: Node) => boolean) | string[]): (state: EditorState, _1?: (tr: Transaction) => void) => boolean;
-export function chainCommands(...commands: Array<(_0: EditorState, _1?: (tr: Transaction) => void) => boolean>): (_0: EditorState, _1?: (tr: Transaction) => void) => boolean;
+export function wrapIn(nodeType: NodeType, attrs?: object): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+export function setBlockType(nodeType: NodeType, attrs?: object): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+export function toggleMark(markType: MarkType, attrs?: object): (state: EditorState, dispatch?: (tr: Transaction) => void) => boolean;
+export function autoJoin(
+    command: (state: EditorState, p1?: (tr: Transaction) => void) => boolean,
+    isJoinable: ((before: Node, after: Node) => boolean) | string[]): (state: EditorState, p1?: (tr: Transaction) => void) => boolean;
+export function chainCommands(...commands: Array<(p1: EditorState, p2?: (tr: Transaction) => void) => boolean>): (p1: EditorState, p2?: (tr: Transaction) => void) => boolean;
 export const baseKeymap: { [key: string]: any };
diff --git a/types/prosemirror-commands/prosemirror-commands-tests.ts b/types/prosemirror-commands/prosemirror-commands-tests.ts
index f013a51d79..648dfeed4c 100644
--- a/types/prosemirror-commands/prosemirror-commands-tests.ts
+++ b/types/prosemirror-commands/prosemirror-commands-tests.ts
@@ -1,5 +1,11 @@
 import * as commands from 'prosemirror-commands';
-import {EditorState} from 'prosemirror-state';
+import { NodeType } from 'prosemirror-model';
+import { EditorState } from 'prosemirror-state';
+
+let nodeType = new NodeType();
 
 let state = new EditorState();
 commands.deleteSelection(state);
+
+commands.baseKeymap["Ctrl-h"];
+commands.wrapIn(nodeType, { attr: 'value' });
diff --git a/types/prosemirror-history/index.d.ts b/types/prosemirror-history/index.d.ts
index 20f5ddd3a0..dbbbded32e 100644
--- a/types/prosemirror-history/index.d.ts
+++ b/types/prosemirror-history/index.d.ts
@@ -3,14 +3,14 @@
 // Definitions by: Bradley Ayers <https://github.com/bradleyayers>
 //                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
-// TypeScript Version: 2.1
+// TypeScript Version: 2.3
 
 import { Plugin } from 'prosemirror-state';
 import { EditorState } from 'prosemirror-state';
 import { Transaction } from 'prosemirror-state';
 
 export function closeHistory(tr: Transaction): Transaction;
-export function history(config?: { depth?: number, newGroupDelay: number, preserveItems?: boolean }): Plugin;
+export function history<T>(config?: { depth?: number, newGroupDelay: number, preserveItems?: boolean }): Plugin<T>;
 export function undo(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 export function redo(state: EditorState, dispatch?: (tr: Transaction) => void): boolean;
 export function undoDepth(state: EditorState): number;
diff --git a/types/prosemirror-inputrules/index.d.ts b/types/prosemirror-inputrules/index.d.ts
index 252ba59b2b..d2c6d9c876 100644
--- a/types/prosemirror-inputrules/index.d.ts
+++ b/types/prosemirror-inputrules/index.d.ts
@@ -1,35 +1,30 @@
-// Type definitions for prosemirror-inputrules 0.18
+// Type definitions for prosemirror-inputrules 0.21
 // Project: https://github.com/ProseMirror/prosemirror-inputrules
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
+import { Node, NodeType } from 'prosemirror-model';
+import { EditorState, Plugin, Transaction } from 'prosemirror-state';
 
-import { EditorState } from 'prosemirror-state'
-import { Transaction } from 'prosemirror-state'
-import { Plugin } from 'prosemirror-state'
-import { NodeType } from 'prosemirror-model'
-import { ProsemirrorNode } from 'prosemirror-model'
-
-declare module "prosemirror-inputrules" {
-  export class InputRule {
-    constructor(match: RegExp, handler: string | ((state: EditorState, match: string[], start: number, end: number) => Transaction))
-
-  }
-  export function inputRules(config: { rules: InputRule[] }): Plugin
-  export let emDash: InputRule;
-  export let ellipsis: InputRule;
-  export let openDoubleQuote: InputRule;
-  export let closeDoubleQuote: InputRule;
-  export let openSingleQuote: InputRule;
-  export let closeSingleQuote: InputRule;
-  export let smartQuotes: InputRule[];
-  export let allInputRules: InputRule[];
-  export function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Object | ((p: string[]) => Object | void), joinPredicate?: (p1: string[], p2: ProsemirrorNode) => boolean): InputRule
-  export function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: Object | ((p: string[]) => Object | void)): InputRule
-  export function blockQuoteRule(nodeType: NodeType): InputRule
-  export function orderedListRule(nodeType: NodeType): InputRule
-  export function bulletListRule(nodeType: NodeType): InputRule
-  export function codeBlockRule(nodeType: NodeType): InputRule
-  export function headingRule(nodeType: NodeType, maxLevel: number): InputRule
-
-}
\ No newline at end of file
+export class InputRule {
+  constructor(match: RegExp, handler: string | ((state: EditorState, match: string[], start: number, end: number) => Transaction | null | undefined))
+}
+export function inputRules(config: { rules: InputRule[] }): Plugin;
+export function undoInputRule(state: EditorState, dispatch?: (p: Transaction) => void): boolean;
+export let emDash: InputRule;
+export let ellipsis: InputRule;
+export let openDoubleQuote: InputRule;
+export let closeDoubleQuote: InputRule;
+export let openSingleQuote: InputRule;
+export let closeSingleQuote: InputRule;
+export let smartQuotes: InputRule[];
+export let allInputRules: InputRule[];
+export function wrappingInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: object | ((p: string[]) => object | null | undefined), joinPredicate?: (p1: string[], p2: Node) => boolean): InputRule;
+export function textblockTypeInputRule(regexp: RegExp, nodeType: NodeType, getAttrs?: object | ((p: string[]) => object | null | undefined)): InputRule;
+export function blockQuoteRule(nodeType: NodeType): InputRule;
+export function orderedListRule(nodeType: NodeType): InputRule;
+export function bulletListRule(nodeType: NodeType): InputRule;
+export function codeBlockRule(nodeType: NodeType): InputRule;
+export function headingRule(nodeType: NodeType, maxLevel: number): InputRule;
diff --git a/types/prosemirror-inputrules/prosemirror-inputrules-tests.ts b/types/prosemirror-inputrules/prosemirror-inputrules-tests.ts
index 85317eaa4c..406a311184 100644
--- a/types/prosemirror-inputrules/prosemirror-inputrules-tests.ts
+++ b/types/prosemirror-inputrules/prosemirror-inputrules-tests.ts
@@ -1,5 +1,5 @@
 import * as inputrules from 'prosemirror-inputrules';
-import { NodeType } from 'prosemirror-model'
+import { NodeType } from 'prosemirror-model';
 
 let nodeType = new NodeType();
 let rule = inputrules.blockQuoteRule(nodeType);
diff --git a/types/prosemirror-inputrules/tslint.json b/types/prosemirror-inputrules/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/prosemirror-inputrules/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/prosemirror-keymap/index.d.ts b/types/prosemirror-keymap/index.d.ts
index 8ae14961c5..b61c0ff1c7 100644
--- a/types/prosemirror-keymap/index.d.ts
+++ b/types/prosemirror-keymap/index.d.ts
@@ -1,13 +1,16 @@
-// Type definitions for prosemirror-keymap 0.18
+// Type definitions for prosemirror-keymap 0.21
 // Project: https://github.com/ProseMirror/prosemirror-keymap
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-import { Plugin } from 'prosemirror-state'
-import { EditorView } from 'prosemirror-view'
+import { Plugin } from 'prosemirror-state';
+import { EditorView } from 'prosemirror-view';
 
-declare module "prosemirror-keymap" {
-  export function keymap(bindings: Object): Plugin
-  export function keydownHandler(bindings: Object): (view: EditorView, event: Event) => boolean
+export interface Bindings {
+    [key: string]: any;
+}
 
-}
\ No newline at end of file
+export function keymap<T>(bindings: Bindings): Plugin<T>;
+export function keydownHandler(bindings: Bindings): (view: EditorView, event: Event) => boolean;
diff --git a/types/prosemirror-keymap/tslint.json b/types/prosemirror-keymap/tslint.json
new file mode 100644
index 0000000000..f93cf8562a
--- /dev/null
+++ b/types/prosemirror-keymap/tslint.json
@@ -0,0 +1,3 @@
+{
+    "extends": "dtslint/dt.json"
+}
diff --git a/types/prosemirror-markdown/index.d.ts b/types/prosemirror-markdown/index.d.ts
new file mode 100644
index 0000000000..0f91962dd6
--- /dev/null
+++ b/types/prosemirror-markdown/index.d.ts
@@ -0,0 +1,60 @@
+// Type definitions for prosemirror-markdown 0.21
+// Project: https://github.com/ProseMirror/prosemirror-markdown
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
+
+import { MarkdownIt } from 'markdown-it';
+import { Mark, Node, Schema } from 'prosemirror-model';
+
+export class MarkdownParser {
+  constructor(schema: Schema, tokenizer: MarkdownIt, tokens: { [key: string]: any });
+}
+
+export type NodeSerializer = (state: MarkdownSerializerState, node?: Node, parent?: Node, index?: number) => void;
+
+export interface MarkSerializer {
+  open: string | ((state: MarkdownSerializerState, mark: Mark) => string);
+  close: string | ((state: MarkdownSerializerState, mark: Mark) => string);
+  mixable?: boolean;
+}
+
+export interface NodeSerializerSpec {
+    [ nodeName: string ]: NodeSerializer;
+}
+
+export interface MarkSerializerSpec {
+    [ markName: string ]: MarkSerializer;
+}
+
+export class MarkdownSerializer {
+  constructor(nodes: NodeSerializerSpec, marks: MarkSerializerSpec);
+  serialize(content: Node, options?: { [key: string]: any }): string;
+  nodes: any;
+  marks: any;
+}
+
+export const defaultMarkdownSerializer: MarkdownSerializer;
+
+export class MarkdownSerializerState {
+  constructor(nodes: NodeSerializerSpec, marks: MarkSerializerSpec, options?: object);
+  flushClose(size: number): void;
+  wrapBlock(delim: string, firstDelim: string | null, node: Node, f: (...args: any[]) => void): void;
+  atBlank(): boolean;
+  ensureNewLine(): void;
+  write(content?: string): void;
+  closeBlock(node: Node): void;
+  text(text: string, escape?: boolean): void;
+  render(node: Node, parent: Node, index: number): void;
+  renderContent(parent: Node): void;
+  renderInline(parent: Node): void;
+  renderList(node: Node, delim: string, firstDelim: (number: number) => string): void;
+  esc(str: string, startOfLine?: boolean): string;
+  quote(str: string): string;
+  repeat(str: string, n: number): string;
+  markString(mark: Mark, open: boolean): string;
+  out: any;
+  closed: any;
+  nodes: any;
+  marks: any;
+}
diff --git a/types/prosemirror-markdown/prosemirror-markdown-tests.ts b/types/prosemirror-markdown/prosemirror-markdown-tests.ts
new file mode 100644
index 0000000000..3a751ad096
--- /dev/null
+++ b/types/prosemirror-markdown/prosemirror-markdown-tests.ts
@@ -0,0 +1 @@
+import * as markdown from 'prosemirror-markdown';
diff --git a/types/prosemirror-markdown/tsconfig.json b/types/prosemirror-markdown/tsconfig.json
new file mode 100644
index 0000000000..bd2598f4c7
--- /dev/null
+++ b/types/prosemirror-markdown/tsconfig.json
@@ -0,0 +1,23 @@
+{
+    "compilerOptions": {
+        "module": "commonjs",
+        "lib": [
+            "es6",
+            "dom"
+        ],
+        "noImplicitAny": true,
+        "noImplicitThis": true,
+        "strictNullChecks": true,
+        "baseUrl": "../",
+        "typeRoots": [
+            "../"
+        ],
+        "types": [],
+        "noEmit": true,
+        "forceConsistentCasingInFileNames": true
+    },
+    "files": [
+        "index.d.ts",
+        "prosemirror-markdown-tests.ts"
+    ]
+}
diff --git a/types/prosemirror-markdown/tslint.json b/types/prosemirror-markdown/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-markdown/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/prosemirror-menu/index.d.ts b/types/prosemirror-menu/index.d.ts
index e4936130eb..3ed389f1f6 100644
--- a/types/prosemirror-menu/index.d.ts
+++ b/types/prosemirror-menu/index.d.ts
@@ -2,60 +2,51 @@
 // Project: https://github.com/ProseMirror/prosemirror-menu
 // Definitions by: David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
+import { EditorView } from 'prosemirror-view';
+import { EditorState } from 'prosemirror-state';
+import { Transaction } from 'prosemirror-state';
+import { Plugin } from 'prosemirror-state';
+import { NodeType } from 'prosemirror-model';
+import { EditorProps } from 'prosemirror-view';
 
-import { ProsemirrorNode } from 'prosemirror-model'
-import { EditorView } from 'prosemirror-view'
-import { EditorState } from 'prosemirror-state'
-import { Transaction } from 'prosemirror-state'
-import { Plugin } from 'prosemirror-state'
-import { NodeType } from 'prosemirror-model'
-import { EditorProps } from 'prosemirror-view'
-
-declare module "prosemirror-menu" {
-  export interface MenuElement {
-    render(pm: any): Node
-
-  }
-  export class MenuItem {
-    constructor(spec: MenuItemSpec)
-    spec: MenuItemSpec;
-    render(view: EditorView): Node
-
-  }
-  export interface MenuItemSpec {
-    run(p1: EditorState, fn: (p: Transaction) => void, p2: EditorView, ev: Event): void
-    select?(p: EditorState): boolean
-    onDeselected?: string;
-    active?(p: EditorState): boolean
-    render?(p: EditorView): Node
-    icon?: Object;
-    label?: string;
-    title?: string | ((s: EditorState) => string);
-    class: string;
-    css: string;
-    execEvent: string;
-
-  }
-  export class Dropdown {
-    constructor(content: MenuElement[], options?: Object)
-    render(view: EditorView): Node
-
-  }
-  export class DropdownSubmenu {
-    constructor(content: MenuElement[], options?: Object)
-    render(view: EditorView): Node
-
-  }
-  export function renderGrouped(view: EditorView, content: MenuElement | MenuElement[][]): DocumentFragment
-  export let icons: Object;
-  export let joinUpItem: MenuItem;
-  export let liftItem: MenuItem;
-  export let selectParentNodeItem: MenuItem;
-  export function undoItem(p: Object): MenuItem
-  export function redoItem(p: Object): MenuItem
-  export function wrapItem(nodeType: NodeType, options: Object): MenuItem
-  export function blockTypeItem(nodeType: NodeType, options: Object): MenuItem
-  export function menuBar(options: { content: MenuElement[][], floating?: boolean }): Plugin
-
-}
\ No newline at end of file
+export interface MenuElement {
+  render(pm: any): Node;
+}
+export class MenuItem {
+  constructor(spec: MenuItemSpec)
+  spec: MenuItemSpec;
+  render(view: EditorView): Node;
+}
+export interface MenuItemSpec {
+  run(p1: EditorState, fn: (p: Transaction) => void, p2: EditorView, ev: Event): void;
+  select?(p: EditorState): boolean;
+  onDeselected?: string;
+  active?(p: EditorState): boolean;
+  render?(p: EditorView): Node;
+  icon?: { [key: string]: any };
+  label?: string;
+  title?: string | ((s: EditorState) => string);
+  class: string;
+  css: string;
+  execEvent: string;
+}
+export class Dropdown {
+  constructor(content: MenuElement[], options?: object)
+  render(view: EditorView): Node;
+}
+export class DropdownSubmenu {
+  constructor(content: MenuElement[], options?: object)
+  render(view: EditorView): Node;
+}
+export function renderGrouped(view: EditorView, content: MenuElement | MenuElement[][]): DocumentFragment;
+export let icons: { [key: string]: any };
+export let joinUpItem: MenuItem;
+export let liftItem: MenuItem;
+export let selectParentNodeItem: MenuItem;
+export function undoItem(p: object): MenuItem;
+export function redoItem(p: object): MenuItem;
+export function wrapItem(nodeType: NodeType, options: object): MenuItem;
+export function blockTypeItem(nodeType: NodeType, options: object): MenuItem;
+export function menuBar(options: { content: MenuElement[][], floating?: boolean }): Plugin;
diff --git a/types/prosemirror-menu/prosemirror-menu-tests.ts b/types/prosemirror-menu/prosemirror-menu-tests.ts
index 0fee71a9cf..961c89223e 100644
--- a/types/prosemirror-menu/prosemirror-menu-tests.ts
+++ b/types/prosemirror-menu/prosemirror-menu-tests.ts
@@ -1,3 +1,3 @@
 import * as menu from 'prosemirror-menu';
 
-let menuBarPlugin = menu.menuBar({ content: [], floating: false });
\ No newline at end of file
+let menuBarPlugin = menu.menuBar({ content: [], floating: false });
diff --git a/types/prosemirror-menu/tslint.json b/types/prosemirror-menu/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-menu/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/prosemirror-model/dom.d.ts b/types/prosemirror-model/dom.d.ts
new file mode 100644
index 0000000000..b4b02d1c24
--- /dev/null
+++ b/types/prosemirror-model/dom.d.ts
@@ -0,0 +1,21 @@
+export type DOMDataTransfer = DataTransfer;
+export type DOMDocument = Document;
+export type DOMElement = HTMLElement;
+export type DOMEvent = Event;
+export type DOMFragment = DocumentFragment;
+export type DOMKeyboardEvent = KeyboardEvent;
+export type DOMMouseEvent = MouseEvent;
+export type DOMMutationRecord = MutationRecord;
+export type DOMNode = Node;
+
+export {
+  DOMDataTransfer as DataTransfer,
+  DOMDocument as Document,
+  DOMElement as Element,
+  DOMEvent as Event,
+  DOMFragment as DocumentFragment,
+  DOMKeyboardEvent as KeyboardEvent,
+  DOMMouseEvent as MouseEvent,
+  DOMMutationRecord as MutationRecord,
+  DOMNode as Node,
+};
diff --git a/types/prosemirror-model/index.d.ts b/types/prosemirror-model/index.d.ts
index 3ede724248..e2b276fcb4 100644
--- a/types/prosemirror-model/index.d.ts
+++ b/types/prosemirror-model/index.d.ts
@@ -1,266 +1,283 @@
-// Type definitions for prosemirror-model 0.18
+// Type definitions for prosemirror-model 0.21
 // Project: https://github.com/ProseMirror/prosemirror-model
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.1
 
-type OrderedMap<T> = T;
-
-declare module "prosemirror-model" {
-  export class ContentMatch {
-    matchNode(node: ProsemirrorNode): ContentMatch
-    matchType(type: NodeType, attrs?: Object, marks?: Mark[]): ContentMatch
-    matchFragment(fragment: Fragment, from?: number, to?: number): ContentMatch | boolean
-    matchToEnd(fragment: Fragment, start?: number, end?: number): boolean
-    validEnd(): boolean
-    fillBefore(after: Fragment, toEnd: boolean, startIndex?: number): Fragment
-    allowsMark(markType: MarkType): boolean
-    findWrapping(target: NodeType, targetAttrs?: Object, targetMarks?: Mark[]): { type: NodeType, attrs: Object }[]
-    findWrappingFor(node: ProsemirrorNode): { type: NodeType, attrs: Object }[]
-
-  }
-  export class Fragment {
-    append(other: Fragment): Fragment
-    cut(from: number, to?: number): Fragment
-    replaceChild(index: number, node: ProsemirrorNode): Fragment
-    eq(other: Fragment): boolean
-    firstChild?: ProsemirrorNode;
-    lastChild?: ProsemirrorNode;
-    childCount: number;
-    child(index: number): ProsemirrorNode
-    offsetAt(index: number): number
-    maybeChild(index: number): ProsemirrorNode
-    forEach(f: (node: ProsemirrorNode, offset: number, index: number) => void): void
-    findDiffStart(other: Fragment): number
-    findDiffEnd(other: ProsemirrorNode): { a: number, b: number } | void
-    toString(): string
-    toJSON(): Object | void
-    static fromJSON(schema: Schema, value?: Object): Fragment
-    static fromArray(array: ProsemirrorNode[]): Fragment
-    static from(nodes?: Fragment | ProsemirrorNode | ProsemirrorNode[]): Fragment
-    static empty: Fragment;
-
-  }
-  export interface ParseRule {
-    tag?: string;
-    style?: string;
-    context?: string;
-    node?: string;
-    mark?: string;
-    priority?: number;
-    ignore?: boolean;
-    skip?: boolean;
-    attrs?: Object;
-    getAttrs?(p: Node | string): boolean | Object
-    contentElement?: string;
-    getContent?(p: Node): Fragment
-    preserveWhitespace?: boolean;
-
-  }
-  export class DOMParser {
-    constructor(schema: Schema, rules: ParseRule[])
-    schema: Schema;
-    rules: ParseRule[];
-    parse(dom: Node, options?: { preserveWhitespace?: boolean, findPositions?: { node: Node, offset: number }[], from?: number, to?: number, topNode?: ProsemirrorNode, topStart?: number, context?: ResolvedPos }): ProsemirrorNode
-    parseSlice(dom: Node, options?: Object): Slice
-    static schemaRules(schema: Schema): ParseRule[]
-    static fromSchema(schema: Schema): DOMParser
-
-  }
-  export class Mark {
-    type: MarkType;
-    attrs: Object;
-    addToSet(set: Mark[]): Mark[]
-    removeFromSet(set: Mark[]): Mark[]
-    isInSet(set: Mark[]): boolean
-    eq(other: Mark): boolean
-    toJSON(): Object
-    static fromJSON(schema: Schema, json: Object): Mark
-    static sameSet(a: Mark[], b: Mark[]): boolean
-    static setFrom(marks?: Mark | Mark[]): Mark[]
-    static none: Mark[];
-
-  }
-  export class ProsemirrorNode {
-    type: NodeType;
-    attrs: Object;
-    content: Fragment;
-    marks: Mark[];
-    text?: string;
-    nodeSize: number;
-    childCount: number;
-    child(index: number): ProsemirrorNode
-    maybeChild(index: number): ProsemirrorNode
-    forEach(f: (node: ProsemirrorNode, offset: number, index: number) => void): void
-    nodesBetween(from: number |  void, to: number |  void, f: (node: ProsemirrorNode, pos: number, parent: ProsemirrorNode, index: number) => void): void
-    descendants(f: (node: ProsemirrorNode, pos: number, parent: ProsemirrorNode) => void): void
-    textContent: string;
-    textBetween(from: number, to: number, blockSeparator?: string, leafText?: string): string
-    firstChild?: ProsemirrorNode;
-    lastChild?: ProsemirrorNode;
-    eq(other: ProsemirrorNode): boolean
-    sameMarkup(other: ProsemirrorNode): boolean
-    hasMarkup(type: NodeType, attrs?: Object, marks?: Mark[]): boolean
-    copy(content?: Fragment): ProsemirrorNode
-    mark(marks: Mark[]): ProsemirrorNode
-    cut(from: number, to?: number): ProsemirrorNode
-    slice(from: number, to?: number): Slice
-    replace(from: number, to: number, slice: Slice): ProsemirrorNode
-    nodeAt(pos: number): ProsemirrorNode
-    childAfter(pos: number): { node?: ProsemirrorNode, index: number, offset: number }
-    childBefore(pos: number): { node?: ProsemirrorNode, index: number, offset: number }
-    resolve(pos: number): ResolvedPos
-    rangeHasMark(from: number |  void, to: number |  void, type: MarkType): boolean
-    isBlock: boolean;
-    isTextblock: boolean;
-    isInline: boolean;
-    isText: boolean;
-    isLeaf: boolean;
-    isAtom: boolean;
-    toString(): string
-    contentMatchAt(index: number): ContentMatch
-    canReplace(from: number, to: number, replacement?: Fragment, start?: number, end?: number): boolean
-    canReplaceWith(from: number, to: number, type: NodeType, attrs?: Mark[]): boolean
-    canAppend(other: ProsemirrorNode): boolean
-    check(): void
-    toJSON(): Object
-    static fromJSON(schema: Schema, json: Object): ProsemirrorNode
-
-  }
-  export class ReplaceError extends Error {
-
-  }
-  export class Slice {
-    constructor(content: Fragment, openLeft: number, openRight: number)
-    content: Fragment;
-    openLeft: number;
-    openRight: number;
-    size: number;
-    toJSON(): Object | void
-    static fromJSON(schema: Schema, json?: Object): Slice
-    static maxOpen(fragment: Fragment): Slice
-    static empty: Slice;
-
-  }
-  export class ResolvedPos {
-    pos: number;
-    depth: number;
-    parentOffset: number;
-    parent: ProsemirrorNode;
-    node(depth?: number): ProsemirrorNode
-    index(depth?: number): number
-    indexAfter(depth?: number): number
-    start(depth?: number): number
-    end(depth?: number): number
-    before(depth?: number): number
-    after(depth?: number): number
-    textOffset: number;
-    nodeAfter?: ProsemirrorNode;
-    nodeBefore?: ProsemirrorNode;
-    marks(after?: boolean): Mark[]
-    sharedDepth(pos: number): number
-    blockRange(other?: ResolvedPos, pred?: (p: ProsemirrorNode) => boolean): NodeRange
-    sameParent(other: ResolvedPos): boolean
-
-  }
-  export class NodeRange {
-    $from: ResolvedPos;
-    $to: ResolvedPos;
-    depth: number;
-    start: number;
-    end: number;
-    parent: ProsemirrorNode;
-    startIndex: number;
-    endIndex: number;
-
-  }
-  export class NodeType {
-    name: string;
-    schema: Schema;
-    spec: NodeSpec;
-    isBlock: boolean;
-    isText: boolean;
-    isInline: boolean;
-    isTextblock: boolean;
-    isLeaf: boolean;
-    isAtom: boolean;
-    create(attrs?: Object, content?: Fragment | ProsemirrorNode | ProsemirrorNode[], marks?: Mark[]): ProsemirrorNode
-    createChecked(attrs?: Object, content?: Fragment | ProsemirrorNode | ProsemirrorNode[], marks?: Mark[]): ProsemirrorNode
-    createAndFill(attrs?: Object, content?: Fragment | ProsemirrorNode | ProsemirrorNode[], marks?: Mark[]): ProsemirrorNode
-    validContent(content: Fragment, attrs?: Object): boolean
-
-  }
-  export class MarkType {
-    name: string;
-    schema: Schema;
-    spec: MarkSpec;
-    create(attrs?: Object): Mark
-    removeFromSet(set: Mark[]): Mark[]
-    isInSet(set: Mark[]): Mark
-    excludes: MarkType;
-
-  }
-  export interface SchemaSpec {
-    nodes: Object | OrderedMap<NodeSpec>;
-    marks?: Object | OrderedMap<MarkSpec>;
-    topNode?: string;
-
-  }
-  export interface NodeSpec {
-    content?: string;
-    group?: string;
-    inline?: boolean;
-    atom?: boolean;
-    attrs?: Object;
-    selectable?: boolean;
-    draggable?: boolean;
-    code?: boolean;
-    defining?: boolean;
-    toDOM?(p: ProsemirrorNode): DOMOutputSpec
-    parseDOM?: ParseRule[];
-
-  }
-  export interface MarkSpec {
-    attrs?: Object;
-    inclusiveRight?: boolean;
-    excludes?: string;
-    group?: string;
-    toDOM?(mark: Mark): DOMOutputSpec
-    parseDOM?: ParseRule[];
-
-  }
-  export interface AttributeSpec {
-    default?: any;
-    compute?(): any
-
-  }
-  export class Schema {
-    constructor(spec: SchemaSpec)
-    spec: SchemaSpec;
-    nodes: {[key: string]: NodeType};
-    marks: {[key: string]: MarkType};
-    cached: Object;
-    topNodeType: NodeType;
-    node(type: string | NodeType, attrs?: Object, content?: Fragment | ProsemirrorNode | ProsemirrorNode[], marks?: Mark[]): ProsemirrorNode
-    text(text: string, marks?: Mark[]): ProsemirrorNode
-    mark(type: string | MarkType, attrs?: Object): Mark
-    nodeFromJSON(json: Object): ProsemirrorNode
-    markFromJSON(json: Object): Mark
-
-  }
-  export interface DOMOutputSpec {
-
-  }
-  export class DOMSerializer {
-    constructor(nodes: Object, marks: Object)
-    nodes: {[key: string]: NodeType};
-    marks: {[key: string]: MarkType};
-    serializeFragment(fragment: Fragment, options?: Object): DocumentFragment
-    serializeNode(node: ProsemirrorNode, options?: Object): Node
-    static renderSpec(doc: Document, structure: DOMOutputSpec): { dom: Node, contentDOM?: Node }
-    static fromSchema(schema: Schema): DOMSerializer
-    static nodesFromSchema(schema: Schema): Object
-    static marksFromSchema(schema: Schema): Object
-
-  }
+import OrderedMap = require('orderedmap');
+import * as dom from './dom';
 
+export interface AnyObject {
+  [key: string]: any;
+}
+
+export class ContentMatch {
+  matchNode(node: Node): ContentMatch | null | undefined;
+  matchType(type: NodeType, attrs?: AnyObject, marks?: Mark[]): ContentMatch | null | undefined;
+  matchFragment(fragment: Fragment, from?: number, to?: number): ContentMatch | boolean | null | undefined;
+  matchToEnd(fragment: Fragment, start?: number, end?: number): boolean;
+  validEnd(): boolean;
+  fillBefore(after: Fragment, toEnd: boolean, startIndex?: number): Fragment | null | undefined;
+  allowsMark(markType: MarkType): boolean;
+  findWrapping(target: NodeType, targetAttrs?: AnyObject, targetMarks?: Mark[]): Array<{ type: NodeType, attrs: AnyObject }> | null | undefined;
+  findWrappingFor(node: Node): Array<{ type: NodeType, attrs: AnyObject }> | null | undefined;
+}
+export class Fragment {
+  nodesBetween(from: number, to: number, f: (node: Node, start: number, parent: Node, index: number) => boolean | null | void): void;
+  descendants(f: (node: Node, pos: number, parent: Node) => boolean | null | void): void;
+  append(other: Fragment): Fragment;
+  cut(from: number, to?: number): Fragment;
+  replaceChild(index: number, node: Node): Fragment;
+  eq(other: Fragment): boolean;
+  firstChild?: Node | null;
+  lastChild?: Node | null;
+  childCount: number;
+  child(index: number): Node;
+  offsetAt(index: number): number;
+  maybeChild(index: number): Node | null | undefined;
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  findDiffStart(other: Fragment): number | null | undefined;
+  findDiffEnd(other: Node): { a: number, b: number } | null | undefined;
+  toString(): string;
+  toJSON(): AnyObject | null | undefined;
+  static fromJSON(schema: Schema, value?: AnyObject): Fragment;
+  static fromArray(array: Node[]): Fragment;
+  static from(nodes?: Fragment | Node | Node[]): Fragment;
+  static empty: Fragment;
+}
+export interface ParseRule {
+  tag?: string | null;
+  namespace?: string | null;
+  style?: string | null;
+  context?: string | null;
+  node?: string | null;
+  mark?: string | null;
+  priority?: number | null;
+  ignore?: boolean | null;
+  skip?: boolean | null;
+  attrs?: AnyObject | null;
+  getAttrs?: ((p: dom.Node | string) => boolean | AnyObject | null | void) | null;
+  contentElement?: string | null;
+  getContent?: ((p: dom.Node) => Fragment) | null;
+  preserveWhitespace?: boolean | 'full' | null;
+}
+export class DOMParser {
+  constructor(schema: Schema, rules: ParseRule[])
+  schema: Schema;
+  rules: ParseRule[];
+  parse(dom: dom.Node, options?: {
+    preserveWhitespace?: boolean | 'full' | null,
+    findPositions?: Array<{ node: Node, offset: number }> | null,
+    from?: number | null,
+    to?: number | null,
+    topNode?: Node | null,
+    topStart?: number | null,
+    context?: ResolvedPos | null
+  }): Node;
+  parseSlice(dom: dom.Node, options?: AnyObject): Slice;
+  static schemaRules(schema: Schema): ParseRule[];
+  static fromSchema(schema: Schema): DOMParser;
+}
+export class Mark {
+  type: MarkType;
+  attrs: AnyObject;
+  addToSet(set: Mark[]): Mark[];
+  removeFromSet(set: Mark[]): Mark[];
+  isInSet(set: Mark[]): boolean;
+  eq(other: Mark): boolean;
+  toJSON(): AnyObject;
+  static fromJSON(schema: Schema, json: AnyObject): Mark;
+  static sameSet(a: Mark[], b: Mark[]): boolean;
+  static setFrom(marks?: Mark | Mark[]): Mark[];
+  static none: Mark[];
+}
+export class Node {
+  type: NodeType;
+  attrs: { [key: string]: any };
+  content: Fragment;
+  marks: Mark[];
+  text?: string | null;
+  nodeSize: number;
+  childCount: number;
+  child(index: number): Node;
+  maybeChild(index: number): Node | null | undefined;
+  forEach(f: (node: Node, offset: number, index: number) => void): void;
+  nodesBetween(from: number | undefined, to: number | undefined, f: (node: Node, pos: number, parent: Node, index: number) => boolean | null | void): void;
+  descendants(f: (node: Node, pos: number, parent: Node) => boolean | null | void): void;
+  textContent: string;
+  textBetween(from: number, to: number, blockSeparator?: string, leafText?: string): string;
+  firstChild?: Node | null;
+  lastChild?: Node | null;
+  eq(other: Node): boolean;
+  sameMarkup(other: Node): boolean;
+  hasMarkup(type: NodeType, attrs?: AnyObject, marks?: Mark[]): boolean;
+  copy(content?: Fragment): Node;
+  mark(marks: Mark[]): Node;
+  cut(from: number, to?: number): Node;
+  slice(from: number, to?: number): Slice;
+  replace(from: number, to: number, slice: Slice): Node;
+  nodeAt(pos: number): Node | null | undefined;
+  childAfter(pos: number): { node?: Node | null, index: number, offset: number };
+  childBefore(pos: number): { node?: Node | null, index: number, offset: number };
+  resolve(pos: number): ResolvedPos;
+  rangeHasMark(from: number | undefined, to: number | undefined, type: MarkType): boolean;
+  isBlock: boolean;
+  isTextblock: boolean;
+  inlineContent: boolean;
+  isInline: boolean;
+  isText: boolean;
+  isLeaf: boolean;
+  isAtom: boolean;
+  toString(): string;
+  contentMatchAt(index: number): ContentMatch;
+  canReplace(from: number, to: number, replacement?: Fragment, start?: number, end?: number): boolean;
+  canReplaceWith(from: number, to: number, type: NodeType, attrs?: Mark[]): boolean;
+  canAppend(other: Node): boolean;
+  check(): void;
+  toJSON(): AnyObject;
+  static fromJSON(schema: Schema, json: AnyObject): Node;
+}
+export class ReplaceError extends Error {
+}
+export class Slice {
+  constructor(content: Fragment, openStart: number, openEnd: number)
+  content: Fragment;
+  openStart: number;
+  openEnd: number;
+  size: number;
+  eq(other: Slice): boolean;
+  toJSON(): AnyObject | null | undefined;
+  static fromJSON(schema: Schema, json?: AnyObject): Slice;
+  static maxOpen(fragment: Fragment): Slice;
+  static empty: Slice;
+}
+export class ResolvedPos {
+  pos: number;
+  depth: number;
+  parentOffset: number;
+  parent: Node;
+  doc: Node;
+  node(depth?: number): Node;
+  index(depth?: number): number;
+  indexAfter(depth?: number): number;
+  start(depth?: number): number;
+  end(depth?: number): number;
+  before(depth?: number): number;
+  after(depth?: number): number;
+  textOffset: number;
+  nodeAfter?: Node | null;
+  nodeBefore?: Node | null;
+  marks(after?: boolean): Mark[];
+  sharedDepth(pos: number): number;
+  blockRange(other?: ResolvedPos, pred?: (p: Node) => boolean): NodeRange | null | undefined;
+  sameParent(other: ResolvedPos): boolean;
+  max(other: ResolvedPos): ResolvedPos;
+  min(other: ResolvedPos): ResolvedPos;
+}
+export class NodeRange {
+  $from: ResolvedPos;
+  $to: ResolvedPos;
+  depth: number;
+  start: number;
+  end: number;
+  parent: Node;
+  startIndex: number;
+  endIndex: number;
+}
+export class NodeType {
+  name: string;
+  schema: Schema;
+  spec: NodeSpec;
+  isBlock: boolean;
+  isText: boolean;
+  isInline: boolean;
+  isTextblock: boolean;
+  inlineContent: boolean;
+  isLeaf: boolean;
+  isAtom: boolean;
+  create(attrs?: AnyObject, content?: Fragment | Node | Node[], marks?: Mark[]): Node;
+  createChecked(attrs?: AnyObject, content?: Fragment | Node | Node[], marks?: Mark[]): Node;
+  createAndFill(attrs?: AnyObject, content?: Fragment | Node | Node[], marks?: Mark[]): Node | null | undefined;
+  validContent(content: Fragment, attrs?: AnyObject): boolean;
+}
+export class MarkType {
+  name: string;
+  schema: Schema;
+  spec: MarkSpec;
+  create(attrs?: AnyObject): Mark;
+  removeFromSet(set: Mark[]): Mark[];
+  isInSet(set: Mark[]): Mark | null | undefined;
+  excludes(other: MarkType): boolean;
+}
+export interface SchemaSpec {
+  nodes: { [name: string]: NodeSpec } | OrderedMap<NodeSpec>;
+  marks?: { [name: string]: MarkSpec } | OrderedMap<MarkSpec> | null;
+  topNode?: string | null;
+}
+export interface NodeSpec {
+  content?: string | null;
+  group?: string | null;
+  inline?: boolean | null;
+  atom?: boolean | null;
+  attrs?: { [name: string]: AttributeSpec } | null;
+  selectable?: boolean | null;
+  draggable?: boolean | null;
+  code?: boolean | null;
+  defining?: boolean | null;
+  isolating?: boolean | null;
+  toDOM?: ((node: Node) => DOMOutputSpec) | null;
+  parseDOM?: ParseRule[] | null;
+}
+export interface MarkSpec {
+  attrs?: { [name: string]: AttributeSpec } | null;
+  inclusive?: boolean | null;
+  excludes?: string | null;
+  group?: string | null;
+  toDOM?: ((mark: Mark, inline: boolean) => DOMOutputSpec) | null;
+  parseDOM?: ParseRule[] | null;
+}
+export interface AttributeSpec {
+  default?: any | null;
+  compute?: (() => any) | null;
+}
+export class Schema {
+  constructor(spec: SchemaSpec)
+  spec: SchemaSpec;
+  nodes: { [name: string]: NodeType };
+  marks: { [name: string]: MarkType };
+  cached: AnyObject;
+  topNodeType: NodeType;
+  node(type: string | NodeType, attrs?: AnyObject, content?: Fragment | Node | Node[], marks?: Mark[]): Node;
+  text(text: string, marks?: Mark[]): Node;
+  mark(type: string | MarkType, attrs?: AnyObject): Mark;
+  nodeFromJSON(json: AnyObject): Node;
+  markFromJSON(json: AnyObject): Mark;
+}
+export interface DOMOutputSpecArray {
+  0: string;
+  1?: DOMOutputSpec | 0 | { [attr: string]: string };
+  2?: DOMOutputSpec | 0;
+  3?: DOMOutputSpec | 0;
+  4?: DOMOutputSpec | 0;
+  5?: DOMOutputSpec | 0;
+  6?: DOMOutputSpec | 0;
+  7?: DOMOutputSpec | 0;
+  8?: DOMOutputSpec | 0;
+  9?: DOMOutputSpec | 0;
+}
+export type DOMOutputSpec
+    = string
+    | dom.Node
+    | DOMOutputSpecArray;
+export class DOMSerializer {
+  constructor(nodes: { [name: string]: (node: Node) => DOMOutputSpec }, marks: { [name: string]: (mark: Mark, inline: boolean) => DOMOutputSpec })
+  nodes: { [name: string]: (node: Node) => DOMOutputSpec };
+  marks: { [name: string]: (mark: Mark) => DOMOutputSpec };
+  serializeFragment(fragment: Fragment, options?: AnyObject): DocumentFragment;
+  serializeNode(node: Node, options?: AnyObject): Node;
+  static renderSpec(doc: Document, structure: DOMOutputSpec): { dom: Node, contentDOM?: Node | null };
+  static fromSchema(schema: Schema): DOMSerializer;
+  static nodesFromSchema(schema: Schema): { [name: string]: (node: Node) => DOMOutputSpec };
+  static marksFromSchema(schema: Schema): { [name: string]: (mark: Mark) => DOMOutputSpec };
 }
diff --git a/types/prosemirror-model/prosemirror-model-tests.ts b/types/prosemirror-model/prosemirror-model-tests.ts
index 1850a259e9..4eccff1511 100644
--- a/types/prosemirror-model/prosemirror-model-tests.ts
+++ b/types/prosemirror-model/prosemirror-model-tests.ts
@@ -1,3 +1,40 @@
 import * as model from 'prosemirror-model';
 
 let fragment = new model.Fragment();
+
+let domOutputSpec: model.DOMOutputSpec;
+
+domOutputSpec = ['div'];
+domOutputSpec = ['div', { class: 'foo' }];
+domOutputSpec = ['div', { class: 'foo' }, 0];
+domOutputSpec = ['div', 0];
+domOutputSpec = ['div', ['div', 0]];
+domOutputSpec = ['div', ['div', { class: 'foo' }]];
+domOutputSpec = ['div', ['div', { class: 'foo' }, 0]];
+
+export const nodeSpec: model.NodeSpec = {
+  attrs: {
+    name: { default: '' },
+  },
+  parseDOM: [{
+    tag: 'span[data-name]',
+    getAttrs(dom) {
+      if (dom instanceof HTMLElement) {
+        return {
+          name: dom.getAttribute('data-name')!
+        };
+      }
+    }
+  }],
+  toDOM(node) {
+    const { name } = node.attrs;
+    const attrs = {
+      'data-emoji-name': name,
+    };
+    return ['span', attrs, 0];
+  }
+};
+
+let node = new model.Node();
+node.nodesBetween(0, 1, () => {});
+node.descendants(() => {});
diff --git a/types/prosemirror-model/tslint.json b/types/prosemirror-model/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-model/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/prosemirror-state/index.d.ts b/types/prosemirror-state/index.d.ts
index 8a71756edb..4cdcfc4723 100644
--- a/types/prosemirror-state/index.d.ts
+++ b/types/prosemirror-state/index.d.ts
@@ -1,109 +1,165 @@
-// Type definitions for prosemirror-state 0.18
+// Type definitions for prosemirror-state 0.21
 // Project: https://github.com/ProseMirror/prosemirror-state
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
-import { EditorProps } from 'prosemirror-view'
-import { EditorView } from 'prosemirror-view'
-import { ResolvedPos } from 'prosemirror-model'
-import { ProsemirrorNode } from 'prosemirror-model'
-import { Mappable } from 'prosemirror-transform'
-import { Mark } from 'prosemirror-model'
-import { Schema } from 'prosemirror-model'
-import { Transform } from 'prosemirror-transform'
-import { Slice } from 'prosemirror-model'
-import { MarkType } from 'prosemirror-model'
+import { Mark, MarkType, Node, ResolvedPos, Schema, Slice } from 'prosemirror-model';
+import { Mappable, Mapping, Transform } from 'prosemirror-transform';
+import { EditorProps, EditorView } from 'prosemirror-view';
 
-declare module "prosemirror-state" {
-  export type PluginSpec = { props?: EditorProps, state?: StateField<any>, key?: PluginKey, view?(p: EditorView): { update?(view: EditorView, prevState: EditorState): void, destroy?(): void }, filterTransaction?(p1: Transaction, p2: EditorState): boolean, appendTransaction?(transactions: Transaction[], oldState: EditorState, newState: EditorState): Transaction };
-  export class Plugin {
-    constructor(spec: PluginSpec)
-    props: EditorProps;
-    spec: Object;
-    getState(state: EditorState): any
+export interface AnyObject {
+  [key: string]: any;
+}
 
-  }
-  export interface StateField<T> {
-    init(config: Object, instance: EditorState): T
-    apply(tr: Transaction, value: T, oldState: EditorState, newState: EditorState): T
-    toJSON?(value: T): any
-    fromJSON?(config: Object, value: any, state: EditorState): T
+export interface PluginSpecProps {
+  // State is not part of this type.
+  // state: EditorProps["state"];
+  // dispatchTransaction?: EditorProps["dispatchTransaction"];
+  handleDOMEvents?: EditorProps["handleDOMEvents"];
+  handleKeyDown?: EditorProps["handleKeyDown"];
+  handleKeyPress?: EditorProps["handleKeyPress"];
+  handleTextInput?: EditorProps["handleTextInput"];
+  handleClickOn?: EditorProps["handleClickOn"];
+  handleClick?: EditorProps["handleClick"];
+  handleDoubleClickOn?: EditorProps["handleDoubleClickOn"];
+  handleDoubleClick?: EditorProps["handleDoubleClick"];
+  handleTripleClickOn?: EditorProps["handleTripleClickOn"];
+  handleTripleClick?: EditorProps["handleTripleClick"];
+  handleContextMenu?: EditorProps["handleContextMenu"];
+  handlePaste?: EditorProps["handlePaste"];
+  handleDrop?: EditorProps["handleDrop"];
+  onFocus?: EditorProps["onFocus"];
+  onBlur?: EditorProps["onBlur"];
+  createSelectionBetween?: EditorProps["createSelectionBetween"];
+  domParser?: EditorProps["domParser"];
+  clipboardParser?: EditorProps["clipboardParser"];
+  transformPasted?: EditorProps["transformPasted"];
+  transformPastedHTML?: EditorProps["transformPastedHTML"];
+  transformPastedText?: EditorProps["transformPastedText"];
+  nodeViews?: EditorProps["nodeViews"];
+  clipboardSerializer?: EditorProps["clipboardSerializer"];
+  decorations?: EditorProps["decorations"];
+  editable?: EditorProps["editable"];
+  attributes?: EditorProps["attributes"];
+  scrollThreshold?: EditorProps["scrollThreshold"];
+  scrollMargin?: EditorProps["scrollMargin"];
+}
 
-  }
-  export class PluginKey {
-    constructor(name?: string)
-    get(state: EditorState): Plugin
-    getState(state: EditorState): any
+export interface PluginSpec<T = any> {
+  props?: PluginSpecProps | null;
+  state?: StateField<T> | null;
+  key?: PluginKey | null;
+  view?: ((p: EditorView) => {
+    update?: ((view: EditorView, prevState: EditorState) => void) | null,
+    destroy?: (() => void) | null
+  }) | null;
+  filterTransaction?: ((p1: Transaction, p2: EditorState) => boolean) | null;
+  appendTransaction?: ((transactions: Transaction[], oldState: EditorState, newState: EditorState) => Transaction | null | undefined) | null;
+}
 
-  }
-  export class Selection {
-    from: number;
-    to: number;
-    $from: ResolvedPos;
-    $to: ResolvedPos;
-    empty: boolean;
-    eq(other: Selection): boolean
-    map(doc: ProsemirrorNode, mapping: Mappable): Selection
-    toJSON(): Object
-    static findFrom($pos: ResolvedPos, dir: number, textOnly?: boolean): Selection
-    static near($pos: ResolvedPos, bias?: number, textOnly?: boolean): Selection
-    static atStart(doc: ProsemirrorNode, textOnly?: boolean): Selection
-    static atEnd(doc: ProsemirrorNode, textOnly?: boolean): Selection
-    static between($anchor: ResolvedPos, $head: ResolvedPos, bias?: number): Selection
-    static fromJSON(doc: ProsemirrorNode, json: Object): Selection
+export class Plugin<T = any> {
+  constructor(spec: PluginSpec<T>)
+  props: PluginSpecProps;
+  spec: AnyObject;
+  getState(state: EditorState): any;
+}
 
-  }
-  export class TextSelection extends Selection {
-    constructor($anchor: ResolvedPos, $head?: ResolvedPos)
-    anchor: number;
-    head: number;
-    $anchor: ResolvedPos;
-    $head: ResolvedPos;
-    static create(doc: ProsemirrorNode, anchor: number, head?: number): TextSelection
-
-  }
-  export class NodeSelection extends Selection {
-    constructor($from: ResolvedPos)
-    node: ProsemirrorNode;
-    static create(doc: ProsemirrorNode, from: number, p1?: number): TextSelection
-    static isSelectable(node: ProsemirrorNode): boolean
-
-  }
-  export class EditorState {
-    doc: ProsemirrorNode;
-    selection: Selection;
-    storedMarks?: Mark[];
-    schema: Schema;
-    plugins: Plugin[];
-    apply(tr: Transaction): EditorState
-    applyTransaction(tr: Transaction): { state: EditorState, transactions: Transaction[] }
-    tr: Transaction;
-    reconfigure(config: Object): EditorState
-    toJSON(pluginFields?: Object): Object
-    static create(config: Object): EditorState
-    static fromJSON(config: Object, json: Object, pluginFields?: Object): EditorState
-
-  }
-  export class Transaction extends Transform {
-    time: number;
-    storedMarks?: Mark[];
-    selection: Selection;
-    setSelection(selection: Selection): Transaction
-    selectionSet: boolean;
-    setStoredMarks(marks?: Mark[]): Transaction
-    storedMarksSet: boolean;
-    setTime(time: number): Transaction
-    replaceSelection(slice: Slice): Transaction
-    replaceSelectionWith(node: ProsemirrorNode, inheritMarks?: boolean): Transaction
-    deleteSelection(): Transaction
-    insertText(text: string, from?: number, to?: number): Transaction
-    setMeta(key: string | Plugin | PluginKey, value: any): Transaction
-    getMeta(key: string | Plugin | PluginKey): any
-    isGeneric: boolean;
-    scrollIntoView(): Transaction
-    addStoredMark(mark: Mark): Transaction
-    removeStoredMark(mark: Mark | MarkType): Transaction
-
-  }
-
-}
\ No newline at end of file
+export interface StateField <T> {
+  init(config: AnyObject, instance: EditorState): T;
+  apply(tr: Transaction, value: T, oldState: EditorState, newState: EditorState): T;
+  toJSON?: ((value: T) => any) | null;
+  fromJSON?: ((config: AnyObject, value: any, state: EditorState) => T) | null;
+}
+export class PluginKey {
+  constructor(name?: string)
+  get(state: EditorState): Plugin | null | undefined;
+  getState(state: EditorState): any | null | undefined;
+}
+export class Selection {
+  constructor($anchor: ResolvedPos, $head: ResolvedPos, ranges?: SelectionRange[])
+  ranges: SelectionRange[];
+  $anchor: ResolvedPos;
+  $head: ResolvedPos;
+  anchor: number;
+  head: number;
+  from: number;
+  to: number;
+  $from: ResolvedPos;
+  $to: ResolvedPos;
+  empty: boolean;
+  eq(p: Selection): boolean;
+  map(doc: Node, mapping: Mappable): Selection;
+  content: Slice;
+  replace(tr: Transaction, content?: Slice): void;
+  replaceWith(tr: Transaction, node: Node): void;
+  toJSON(): AnyObject;
+  getBookmark(): SelectionBookmark;
+  visible: boolean;
+  static findFrom($pos: ResolvedPos, dir: number, textOnly?: boolean): Selection | null | undefined;
+  static near($pos: ResolvedPos, bias?: number): Selection;
+  static atStart(doc: Node): Selection;
+  static atEnd(doc: Node): Selection;
+  static fromJSON(doc: Node, json: AnyObject): Selection;
+  static jsonID(id: string, selectionClass: { new(...args: any[]): Selection }): void;
+}
+export interface SelectionBookmark {
+  map(mapping: Mapping): SelectionBookmark;
+  resolve(doc: Node): Selection;
+}
+export class SelectionRange {
+  constructor($from: ResolvedPos, $to: ResolvedPos)
+  $from: ResolvedPos;
+  $to: ResolvedPos;
+}
+export class TextSelection extends Selection {
+  constructor($anchor: ResolvedPos, $head?: ResolvedPos)
+  $cursor?: ResolvedPos | null;
+  static create(doc: Node, anchor: number, head?: number): TextSelection;
+  static between($anchor: ResolvedPos, $head: ResolvedPos, bias?: number): Selection;
+}
+export class NodeSelection extends Selection {
+  constructor($pos: ResolvedPos)
+  node: Node;
+  static create(doc: Node, from: number, p1?: number): NodeSelection;
+  static isSelectable(node: Node): boolean;
+}
+export class AllSelection extends Selection {
+  constructor(doc: Node)
+}
+export class EditorState {
+  doc: Node;
+  selection: Selection;
+  storedMarks?: Mark[] | null;
+  schema: Schema;
+  plugins: Plugin[];
+  apply(tr: Transaction): EditorState;
+  applyTransaction(tr: Transaction): { state: EditorState, transactions: Transaction[] };
+  tr: Transaction;
+  reconfigure(config: AnyObject): EditorState;
+  toJSON(pluginFields?: { [name: string]: Plugin }): AnyObject;
+  static create(config: AnyObject): EditorState;
+  static fromJSON(config: AnyObject, json: AnyObject, pluginFields?: { [name: string]: Plugin }): EditorState;
+}
+export class Transaction extends Transform {
+  time: number;
+  storedMarks?: Mark[] | null;
+  selection: Selection;
+  setSelection(selection: Selection): Transaction;
+  selectionSet: boolean;
+  setStoredMarks(marks?: Mark[]): Transaction;
+  ensureMarks(marks: Mark[]): Transaction;
+  storedMarksSet: boolean;
+  setTime(time: number): Transaction;
+  replaceSelection(slice: Slice): Transaction;
+  replaceSelectionWith(node: Node, inheritMarks?: boolean): Transaction;
+  deleteSelection(): Transaction;
+  insertText(text: string, from?: number, to?: number): Transaction;
+  setMeta(key: string | Plugin | PluginKey, value: any): Transaction;
+  getMeta(key: string | Plugin | PluginKey): any;
+  isGeneric: boolean;
+  scrollIntoView(): Transaction;
+  addStoredMark(mark: Mark): Transaction;
+  removeStoredMark(mark: Mark | MarkType): Transaction;
+}
diff --git a/types/prosemirror-state/prosemirror-state-tests.ts b/types/prosemirror-state/prosemirror-state-tests.ts
index 9daf2b56c5..92989a132e 100644
--- a/types/prosemirror-state/prosemirror-state-tests.ts
+++ b/types/prosemirror-state/prosemirror-state-tests.ts
@@ -1,4 +1,8 @@
 import * as state from 'prosemirror-state';
 
-let spec: state.PluginSpec = {};
-let plugin = new state.Plugin(spec);
+let plugin: state.Plugin;
+
+plugin = new state.Plugin({});
+plugin = new state.Plugin({
+    props: {}
+});
diff --git a/types/prosemirror-state/tslint.json b/types/prosemirror-state/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-state/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/prosemirror-transform/index.d.ts b/types/prosemirror-transform/index.d.ts
index 26c912ccd7..ff84a3a6de 100644
--- a/types/prosemirror-transform/index.d.ts
+++ b/types/prosemirror-transform/index.d.ts
@@ -1,120 +1,100 @@
-// Type definitions for prosemirror-transform 0.18
+// Type definitions for prosemirror-transform 0.21
 // Project: https://github.com/ProseMirror/prosemirror-transform
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
+import { Fragment, Mark, MarkType, Node, NodeRange, NodeType, Schema, Slice } from 'prosemirror-model';
 
-import { ProsemirrorNode } from 'prosemirror-model'
-import { Mark } from 'prosemirror-model'
-import { MarkType } from 'prosemirror-model'
-import { Slice } from 'prosemirror-model'
-import { Fragment } from 'prosemirror-model'
-import { NodeRange } from 'prosemirror-model'
-import { NodeType } from 'prosemirror-model'
-import { Schema } from 'prosemirror-model'
-
-declare module "prosemirror-transform" {
-  export interface Mappable {
-    map(pos: number, assoc?: number): number
-    mapResult(pos: number, assoc?: number): MapResult
-
-  }
-  export class MapResult {
-    pos: number;
-    deleted: boolean;
-
-  }
-  export class StepMap {
-    constructor(ranges: number[])
-    mapResult(pos: number, assoc?: number): MapResult
-    map(pos: number, assoc?: number): number
-    forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void
-    invert(): StepMap
-
-  }
-  export class Mapping {
-    constructor(maps?: StepMap[])
-    maps: StepMap[];
-    from: number;
-    to: number;
-    slice(from?: number, to?: number): Mapping
-    appendMap(map: StepMap, mirrors?: number): void
-    appendMapping(mapping: Mapping): void
-    appendMappingInverted(mapping: Mapping): void
-    map(pos: number, assoc?: number): number
-    mapResult(pos: number, assoc?: number): MapResult
-
-  }
-  export class Transform {
-    constructor(doc: ProsemirrorNode)
-    addMark(from: number, to: number, mark: Mark): Transform
-    removeMark(from: number, to: number, mark?: Mark | MarkType): Transform
-    clearMarkup(from: number, to: number): Transform
-    replaceRange(from: number, to: number, slice: Slice): Transform
-    replaceRangeWith(from: number, to: number, node: ProsemirrorNode): Transform
-    deleteRange(from: number, to: number): Transform
-    delete(from: number, to: number): Transform
-    replace(from: number, to?: number, slice?: Slice): Transform
-    replaceWith(from: number, to: number, content: Fragment | ProsemirrorNode | ProsemirrorNode[]): Transform
-    insert(pos: number, content: Fragment | ProsemirrorNode | ProsemirrorNode[]): Transform
-    lift(range: NodeRange, target: number): Transform
-    wrap(range: NodeRange, wrappers: { type: NodeType, attrs?: Object }[]): Transform
-    setBlockType(from: number, to: number |  void, type: NodeType, attrs?: Object): Transform
-    setNodeType(pos: number, type?: NodeType, attrs?: Object, marks?: Mark[]): Transform
-    split(pos: number, depth?: number, typesAfter?: { type: NodeType, attrs?: Object }[]): Transform
-    join(pos: number, depth?: number, p1?: boolean): Transform
-    doc: ProsemirrorNode;
-    steps: Step[];
-    docs: ProsemirrorNode[];
-    mapping: Mapping;
-    before: ProsemirrorNode;
-    step(step: Step): Transform
-    maybeStep(step: Step): StepResult
-    docChanged: boolean;
-
-  }
-  export class AddMarkStep extends Step {
-    constructor(from: number, to: number, mark: Mark)
-
-  }
-  export class RemoveMarkStep extends Step {
-    constructor(from: number, to: number, mark: Mark)
-
-  }
-  export function replaceStep(doc: ProsemirrorNode, from: number, to?: number, slice?: Slice): Step
-  export class ReplaceStep extends Step {
-    constructor(from: number, to: number, slice: Slice, structure?: boolean)
-
-  }
-  export class ReplaceAroundStep extends Step {
-    constructor(from: number, to: number, gapFrom: number, gapTo: number, slice: Slice, insert: number, structure?: boolean)
-
-  }
-  export class Step {
-    apply(doc: ProsemirrorNode): StepResult
-    getMap(): StepMap
-    invert(doc: ProsemirrorNode): Step
-    map(mapping: Mappable): Step
-    merge(other: Step): Step
-    offset(n: number): Step
-    toJSON(): Object
-    static fromJSON(schema: Schema, json: Object): Step
-    static jsonID(id: string, stepClass: Step): void
-
-  }
-  export class StepResult {
-    doc?: ProsemirrorNode;
-    failed?: string;
-    static ok(doc: ProsemirrorNode): StepResult
-    static fail(message: string): StepResult
-    static fromReplace(doc: ProsemirrorNode, from: number, to: number, slice: Slice): StepResult
-
-  }
-  export function liftTarget(range: NodeRange): number
-  export function findWrapping(range: NodeRange, nodeType: NodeType, attrs?: Object): { type: NodeType, attrs?: Object }[]
-  export function canSplit(doc: ProsemirrorNode, pos: number, depth?: { type: NodeType, attrs?: Object }[]): boolean
-  export function canJoin(doc: ProsemirrorNode, pos: number): boolean
-  export function joinPoint(doc: ProsemirrorNode, pos: number, dir?: number): number
-  export function insertPoint(doc: ProsemirrorNode, pos: number, nodeType: NodeType, attrs?: Object): number
-
-}
\ No newline at end of file
+export interface Mappable {
+  map(pos: number, assoc?: number): number;
+  mapResult(pos: number, assoc?: number): MapResult;
+}
+export class MapResult {
+  pos: number;
+  deleted: boolean;
+}
+export class StepMap {
+  constructor(ranges: number[])
+  mapResult(pos: number, assoc?: number): MapResult;
+  map(pos: number, assoc?: number): number;
+  forEach(f: (oldStart: number, oldEnd: number, newStart: number, newEnd: number) => void): void;
+  invert(): StepMap;
+}
+export class Mapping {
+  constructor(maps?: StepMap[])
+  maps: StepMap[];
+  from: number;
+  to: number;
+  slice(from?: number, to?: number): Mapping;
+  appendMap(map: StepMap, mirrors?: number): void;
+  appendMapping(mapping: Mapping): void;
+  appendMappingInverted(mapping: Mapping): void;
+  map(pos: number, assoc?: number): number;
+  mapResult(pos: number, assoc?: number): MapResult;
+}
+export class AddMarkStep extends Step {
+  constructor(from: number, to: number, mark: Mark)
+}
+export class RemoveMarkStep extends Step {
+  constructor(from: number, to: number, mark: Mark)
+}
+export class Transform {
+  constructor(doc: Node)
+  addMark(from: number, to: number, mark: Mark): Transform;
+  removeMark(from: number, to: number, mark?: Mark | MarkType): Transform;
+  clearMarkup(from: number, to: number): Transform;
+  replaceRange(from: number, to: number, slice: Slice): Transform;
+  replaceRangeWith(from: number, to: number, node: Node): Transform;
+  deleteRange(from: number, to: number): Transform;
+  delete(from: number, to: number): Transform;
+  replace(from: number, to?: number, slice?: Slice): Transform;
+  replaceWith(from: number, to: number, content: Fragment | Node | Node[]): Transform;
+  insert(pos: number, content: Fragment | Node | Node[]): Transform;
+  lift(range: NodeRange, target: number): Transform;
+  wrap(range: NodeRange, wrappers: Array<{ type: NodeType, attrs?: object | null }>): Transform;
+  setBlockType(from: number, to: number | undefined, type: NodeType, attrs?: object): Transform;
+  setNodeType(pos: number, type?: NodeType, attrs?: object, marks?: Mark[]): Transform;
+  split(pos: number, depth?: number, typesAfter?: Array<{ type: NodeType, attrs?: object | null }>): Transform;
+  join(pos: number, depth?: number, p1?: boolean): Transform;
+  doc: Node;
+  steps: Step[];
+  docs: Node[];
+  mapping: Mapping;
+  before: Node;
+  step(step: Step): Transform;
+  maybeStep(step: Step): StepResult;
+  docChanged: boolean;
+}
+export class ReplaceStep extends Step {
+  constructor(from: number, to: number, slice: Slice, structure?: boolean)
+}
+export class ReplaceAroundStep extends Step {
+  constructor(from: number, to: number, gapFrom: number, gapTo: number, slice: Slice, insert: number, structure?: boolean)
+}
+export function replaceStep(doc: Node, from: number, to?: number, slice?: Slice): Step | null | undefined;
+export class Step {
+  apply(doc: Node): StepResult;
+  getMap(): StepMap;
+  invert(doc: Node): Step;
+  map(mapping: Mappable): Step | null | undefined;
+  merge(other: Step): Step | null | undefined;
+  offset(n: number): Step;
+  toJSON(): object;
+  static fromJSON(schema: Schema, json: object): Step;
+  static jsonID(id: string, stepClass: { new(...args: any[]): Step }): void;
+}
+export class StepResult {
+  doc?: Node | null;
+  failed?: string | null;
+  static ok(doc: Node): StepResult;
+  static fail(message: string): StepResult;
+  static fromReplace(doc: Node, from: number, to: number, slice: Slice): StepResult;
+}
+export function liftTarget(range: NodeRange): number | null | undefined;
+export function findWrapping(range: NodeRange, nodeType: NodeType, attrs?: object): Array<{ type: NodeType, attrs?: object | null }> | null | undefined;
+export function canSplit(doc: Node, pos: number, depth?: number, typesAfter?: Array<{ type: NodeType, attrs?: object | null }>): boolean;
+export function canJoin(doc: Node, pos: number): boolean;
+export function joinPoint(doc: Node, pos: number, dir?: number): number | null | undefined;
+export function insertPoint(doc: Node, pos: number, nodeType: NodeType, attrs?: object): number | null | undefined;
diff --git a/types/prosemirror-transform/tslint.json b/types/prosemirror-transform/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-transform/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }
diff --git a/types/prosemirror-view/dom.d.ts b/types/prosemirror-view/dom.d.ts
new file mode 100644
index 0000000000..b4b02d1c24
--- /dev/null
+++ b/types/prosemirror-view/dom.d.ts
@@ -0,0 +1,21 @@
+export type DOMDataTransfer = DataTransfer;
+export type DOMDocument = Document;
+export type DOMElement = HTMLElement;
+export type DOMEvent = Event;
+export type DOMFragment = DocumentFragment;
+export type DOMKeyboardEvent = KeyboardEvent;
+export type DOMMouseEvent = MouseEvent;
+export type DOMMutationRecord = MutationRecord;
+export type DOMNode = Node;
+
+export {
+  DOMDataTransfer as DataTransfer,
+  DOMDocument as Document,
+  DOMElement as Element,
+  DOMEvent as Event,
+  DOMFragment as DocumentFragment,
+  DOMKeyboardEvent as KeyboardEvent,
+  DOMMouseEvent as MouseEvent,
+  DOMMutationRecord as MutationRecord,
+  DOMNode as Node,
+};
diff --git a/types/prosemirror-view/index.d.ts b/types/prosemirror-view/index.d.ts
index 7e0fc118e0..c5fda64a87 100644
--- a/types/prosemirror-view/index.d.ts
+++ b/types/prosemirror-view/index.d.ts
@@ -1,100 +1,92 @@
-// Type definitions for prosemirror-view 0.18
+// Type definitions for prosemirror-view 0.21
 // Project: https://github.com/ProseMirror/prosemirror-view
-// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions by: Bradley Ayers <https://github.com/bradleyayers>
+//                 David Hahn <https://github.com/davidka>
 // Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+// TypeScript Version: 2.3
 
+import { DOMParser, DOMSerializer, Node, ResolvedPos, Slice } from 'prosemirror-model';
+import { EditorState, Selection, Transaction } from 'prosemirror-state';
+import { Mapping } from 'prosemirror-transform';
+import * as dom from './dom';
 
-import { ProsemirrorNode } from 'prosemirror-model'
-import { Mapping } from 'prosemirror-transform'
-import { EditorState } from 'prosemirror-state'
-import { Transaction } from 'prosemirror-state'
-import { DOMParser } from 'prosemirror-model'
-import { Slice } from 'prosemirror-model'
-import { DOMSerializer } from 'prosemirror-model'
-
-declare module "prosemirror-view" {
-  export class Decoration {
-    spec: Object;
-    static widget(pos: number, dom: Node, spec?: { associative?: string, stopEvent?(event: Event): boolean, key?: string }): Decoration
-    static inline(from: number, to: number, attrs: DecorationAttrs, spec?: { inclusiveLeft?: boolean, inclusiveRight?: boolean }): Decoration
-    static node(from: number, to: number, attrs: DecorationAttrs, spec?: Object): Decoration
-
-  }
-  export interface DecorationAttrs {
-    class?: string;
-    style?: string;
-    nodeName?: string;
-
-  }
-  export class DecorationSet {
-    find(start?: number, end?: number): Decoration[]
-    map(mapping: Mapping, doc: ProsemirrorNode, options?: { onRemove?(decorationSpec: Object): void }): DecorationSet
-    add(doc: ProsemirrorNode, decorations: Decoration[]): DecorationSet
-    remove(decorations: Decoration[]): DecorationSet
-    static create(doc: ProsemirrorNode, decorations: Decoration[]): DecorationSet
-    static empty: DecorationSet;
-
-  }
-  export class EditorView {
-    constructor(place: Node | ((p: Node) => void) | { mount: Node } |  void, props: EditorProps)
-    state: EditorState;
-    dom: Element;
-    props: EditorProps;
-    update(props: EditorProps): void
-    setProps(props: EditorProps): void
-    updateState(state: EditorState): void
-    hasFocus(): boolean
-    someProp(propName: string, f: (prop: any) => any): any
-    focus(): void
-    root: Document | DocumentFragment;
-    posAtCoords(coords: { left: number, top: number }): { pos: number, inside: number } | void
-    coordsAtPos(pos: number): { left: number, right: number, top: number, bottom: number }
-    endOfTextblock(dir: "up" | "down" | "left" | "right" | "forward" | "backward", state?: EditorState): boolean
-    destroy(): void
-    dispatch(tr: Transaction): void
-
-  }
-  export interface EditorProps {
-    state: EditorState;
-    dispatchTransaction?(tr: Transaction): void
-    handleDOMEvents?: Object;
-    handleKeyDown?(view: EditorView, event: KeyboardEvent): boolean
-    handleKeyPress?(view: EditorView, event: KeyboardEvent): boolean
-    handleTextInput?(view: EditorView, from: number, to: number, text: string): boolean
-    handleClickOn?(view: EditorView, pos: number, node: ProsemirrorNode, nodePos: number, event: MouseEvent, direct: boolean): boolean
-    handleClick?(view: EditorView, pos: number, event: MouseEvent): boolean
-    handleDoubleClickOn?(view: EditorView, pos: number, node: ProsemirrorNode, nodePos: number, event: MouseEvent, direct: boolean): boolean
-    handleDoubleClick?(view: EditorView, pos: number, event: MouseEvent): boolean
-    handleTripleClickOn?(view: EditorView, pos: number, node: ProsemirrorNode, nodePos: number, event: MouseEvent, direct: boolean): boolean
-    handleTripleClick?(view: EditorView, pos: number, event: MouseEvent): boolean
-    handleContextMenu?(view: EditorView, pos: number, event: MouseEvent): boolean
-    onFocus?(view: EditorView, event: Event): void
-    onBlur?(view: EditorView, event: Event): void
-    domParser?: DOMParser;
-    clipboardParser?: DOMParser;
-    transformPasted?(p: Slice): Slice
-    transformPastedHTML?(p: string): string
-    transformPastedText?(p: string): string
-    nodeViews?: Object;
-    clipboardSerializer?: DOMSerializer;
-    decorations?(p: EditorState): DecorationSet
-    editable?(p: EditorState): boolean
-    attributes?: Object | ((p: EditorState) => Object | void);
-    scrollThreshold?: number;
-    scrollMargin?: number;
-
-  }
-  export interface NodeView {
-    dom?: Node;
-    contentDOM?: Node;
-    update?(node: ProsemirrorNode, decorations: Decoration[]): boolean
-    selectNode?(): void
-    deselectNode?(): void
-    setSelection?(anchor: number, head: number, root: Document): void
-    stopEvent?(event: Event): boolean
-    ignoreMutation?(p: MutationRecord): boolean
-    destroy?(): void
-
-  }
-
-}
\ No newline at end of file
+export class Decoration {
+  spec: object;
+  static widget(pos: number, dom: Node, spec?: { side?: number | null, stopEvent?: ((event: Event) => boolean) | null, key?: string | null }): Decoration;
+  static inline(from: number, to: number, attrs: DecorationAttrs, spec?: { inclusiveStart?: boolean | null, inclusiveEnd?: boolean | null }): Decoration;
+  static node(from: number, to: number, attrs: DecorationAttrs, spec?: object): Decoration;
+}
+export interface DecorationAttrs {
+  class?: string | null;
+  style?: string | null;
+  nodeName?: string | null;
+}
+export class DecorationSet {
+  find(start?: number, end?: number): Decoration[];
+  map(mapping: Mapping, doc: Node, options?: { onRemove?: ((decorationSpec: object) => void) | null }): DecorationSet;
+  add(doc: Node, decorations: Decoration[]): DecorationSet;
+  remove(decorations: Decoration[]): DecorationSet;
+  static create(doc: Node, decorations: Decoration[]): DecorationSet;
+  static empty: DecorationSet;
+}
+export class EditorView {
+  constructor(place: dom.Node | ((p: dom.Node) => void) | { mount: dom.Node } | undefined, props: EditorProps)
+  state: EditorState;
+  dom: Element;
+  props: EditorProps;
+  update(props: EditorProps): void;
+  setProps(props: EditorProps): void;
+  updateState(state: EditorState): void;
+  hasFocus(): boolean;
+  someProp(propName: string, f: (prop: any) => any): any;
+  focus(): void;
+  root: Document | DocumentFragment;
+  posAtCoords(coords: { left: number, top: number }): { pos: number, inside: number } | null | undefined;
+  coordsAtPos(pos: number): { left: number, right: number, top: number, bottom: number };
+  endOfTextblock(dir: 'up' | 'down' | 'left' | 'right' | 'forward' | 'backward', state?: EditorState): boolean;
+  destroy(): void;
+  dispatch(tr: Transaction): void;
+}
+export interface EditorProps {
+  state: EditorState;
+  dispatchTransaction?: ((tr: Transaction) => void) | null;
+  handleDOMEvents?: { [name: string]: (view: EditorView, event: Event) => boolean } | null;
+  handleKeyDown?: ((view: EditorView, event: KeyboardEvent) => boolean) | null;
+  handleKeyPress?: ((view: EditorView, event: KeyboardEvent) => boolean) | null;
+  handleTextInput?: ((view: EditorView, from: number, to: number, text: string) => boolean) | null;
+  handleClickOn?: ((view: EditorView, pos: number, node: Node, nodePos: number, event: MouseEvent, direct: boolean) => boolean) | null;
+  handleClick?: ((view: EditorView, pos: number, event: MouseEvent) => boolean) | null;
+  handleDoubleClickOn?: ((view: EditorView, pos: number, node: Node, nodePos: number, event: MouseEvent, direct: boolean) => boolean) | null;
+  handleDoubleClick?: ((view: EditorView, pos: number, event: MouseEvent) => boolean) | null;
+  handleTripleClickOn?: ((view: EditorView, pos: number, node: Node, nodePos: number, event: MouseEvent, direct: boolean) => boolean) | null;
+  handleTripleClick?: ((view: EditorView, pos: number, event: MouseEvent) => boolean) | null;
+  handleContextMenu?: ((view: EditorView, pos: number, event: MouseEvent) => boolean) | null;
+  handlePaste?: ((view: EditorView, event: Event, slice: Slice) => boolean) | null;
+  handleDrop?: ((view: EditorView, event: Event, slice: Slice, moved: boolean) => boolean) | null;
+  onFocus?: ((view: EditorView, event: Event) => void) | null;
+  onBlur?: ((view: EditorView, event: Event) => void) | null;
+  createSelectionBetween?: ((view: EditorView, anchor: ResolvedPos, head: ResolvedPos) => Selection | null | undefined) | null;
+  domParser?: DOMParser | null;
+  clipboardParser?: DOMParser | null;
+  transformPasted?: ((p: Slice) => Slice) | null;
+  transformPastedHTML?: ((p: string) => string) | null;
+  transformPastedText?: ((p: string) => string) | null;
+  nodeViews?: { [name: string]: (node: Node, view: EditorView, getPos: () => number, decorations: Decoration[]) => NodeView } | null;
+  clipboardSerializer?: DOMSerializer | null;
+  decorations?: ((p: EditorState) => DecorationSet | null | undefined) | null;
+  editable?: ((p: EditorState) => boolean) | null;
+  attributes?: { [name: string]: string } | ((p: EditorState) => { [name: string]: string } | null | undefined) | null;
+  scrollThreshold?: number | null;
+  scrollMargin?: number | null;
+}
+export interface NodeView {
+  dom?: dom.Node | null;
+  contentDOM?: dom.Node | null;
+  update?: ((node: Node, decorations: Decoration[]) => boolean) | null;
+  selectNode?: (() => void) | null;
+  deselectNode?: (() => void) | null;
+  setSelection?: ((anchor: number, head: number, root: Document) => void) | null;
+  stopEvent?: ((event: Event) => boolean) | null;
+  ignoreMutation?: ((p: MutationRecord) => boolean) | null;
+  destroy?: (() => void) | null;
+}
diff --git a/types/prosemirror-view/tslint.json b/types/prosemirror-view/tslint.json
new file mode 100644
index 0000000000..3db14f85ea
--- /dev/null
+++ b/types/prosemirror-view/tslint.json
@@ -0,0 +1 @@
+{ "extends": "dtslint/dt.json" }