Merge pull request #15033 from davidka/master

Added type definitions for several prosemirror modules

prosemirror-collab/index.d.ts

@@ -0,0 +1,17 @@
+// Type definitions for prosemirror-collab 0.18
+// Project: https://github.com/ProseMirror/prosemirror-collab
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { Plugin } from 'prosemirror-state'
+import { EditorState } from 'prosemirror-state'
+import { Step } from 'prosemirror-transform'
+import { Transaction } from 'prosemirror-state'
+
+declare module "prosemirror-collab" {
+  export function collab(config?: { version?: number, clientID?: number }): Plugin
+  export function receiveTransaction(state: EditorState, steps: Step[], clientIDs: number[]): Transaction
+  export function sendableSteps(state: EditorState): { version: number, steps: Step[], clientID: number, origins: Transaction[] } | void
+  export function getVersion(state: EditorState): number
+
+}

prosemirror-collab/prosemirror-collab-tests.ts

@@ -0,0 +1,5 @@
+import * as collab from 'prosemirror-collab';
+import {EditorState} from 'prosemirror-state';
+
+let state = new EditorState();
+let version = collab.getVersion(state);

prosemirror-collab/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-collab-tests.ts"
+    ]
+}

prosemirror-commands/index.d.ts

@@ -0,0 +1,35 @@
+// Type definitions for prosemirror-commands 0.18
+// Project: https://github.com/ProseMirror/prosemirror-commands
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+import { EditorState } from 'prosemirror-state'
+import { Transaction } from 'prosemirror-state'
+import { EditorView } from 'prosemirror-view'
+import { NodeType } from 'prosemirror-model'
+import { MarkType } from 'prosemirror-model'
+import { ProsemirrorNode } from 'prosemirror-model'
+
+declare module "prosemirror-commands" {
+  export function deleteSelection(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function joinBackward(state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView): boolean
+  export function joinForward(state: EditorState, dispatch?: (tr: Transaction) => void, view?: EditorView): boolean
+  export function joinUp(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function joinDown(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function lift(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function newlineInCode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function exitCode(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function createParagraphNear(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function liftEmptyBlock(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function splitBlock(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function splitBlockKeepMarks(state: EditorState, dispatch?: (tr: Transaction) => void): boolean
+  export function selectParentNode(state: EditorState, dispatch?: (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, fn?: (tr: Transaction) => void) => boolean, isJoinable: ((before: ProsemirrorNode, after: ProsemirrorNode) => boolean) | string[]): (state: EditorState, fn?: (tr: Transaction) => void) => boolean
+  export function chainCommands(...commands: ((p1: EditorState, fn?: (tr: Transaction) => void) => boolean)[]): (p1: EditorState, fn?: (tr: Transaction) => void) => boolean
+  export let baseKeymap: Object;
+
+}

prosemirror-commands/prosemirror-commands-tests.ts

@@ -0,0 +1,5 @@
+import * as commands from 'prosemirror-commands';
+import {EditorState} from 'prosemirror-state';
+
+let state = new EditorState();
+commands.deleteSelection(state);

prosemirror-commands/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-commands-tests.ts"
+    ]
+}

prosemirror-history/index.d.ts

@@ -0,0 +1,17 @@
+// Type definitions for prosemirror-history 0.18
+// Project: https://github.com/ProseMirror/prosemirror-history
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+import { Plugin } from 'prosemirror-state'
+import { EditorState } from 'prosemirror-state'
+import { Transaction } from 'prosemirror-state'
+
+declare module "prosemirror-history" {
+  export function history(config?: { depth?: number, newGroupDelay: number, preserveItems?: boolean }): Plugin
+  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
+  export function redoDepth(state: EditorState): number
+
+}

prosemirror-history/prosemirror-history-tests.ts

@@ -0,0 +1,5 @@
+import * as history from 'prosemirror-history';
+import {EditorState} from 'prosemirror-state';
+
+let state = new EditorState();
+history.undo(state);

prosemirror-history/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-history-tests.ts"
+    ]
+}

prosemirror-inputrules/index.d.ts

@@ -0,0 +1,35 @@
+// Type definitions for prosemirror-inputrules 0.18
+// Project: https://github.com/ProseMirror/prosemirror-inputrules
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+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
+
+}

prosemirror-inputrules/prosemirror-inputrules-tests.ts

@@ -0,0 +1,5 @@
+import * as inputrules from 'prosemirror-inputrules';
+import { NodeType } from 'prosemirror-model'
+
+let nodeType = new NodeType();
+let rule = inputrules.blockQuoteRule(nodeType);

prosemirror-inputrules/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-inputrules-tests.ts"
+    ]
+}

prosemirror-keymap/index.d.ts

@@ -0,0 +1,13 @@
+// Type definitions for prosemirror-keymap 0.18
+// Project: https://github.com/ProseMirror/prosemirror-keymap
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+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
+
+}

prosemirror-keymap/prosemirror-keymap-tests.ts

@@ -0,0 +1,3 @@
+import * as keymap from 'prosemirror-keymap';
+
+keymap.keymap({});

prosemirror-keymap/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-keymap-tests.ts"
+    ]
+}

prosemirror-menu/index.d.ts

@@ -0,0 +1,68 @@
+// Type definitions for prosemirror-menu 0.18
+// Project: https://github.com/ProseMirror/prosemirror-menu
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+import { ProsemirrorNode } from 'prosemirror-model'
+import { EditorView } from 'prosemirror-view'
+import { EditorState } from 'prosemirror-state'
+import { Transaction } 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): void
+    select?(p: EditorState): boolean
+    onDeselect?: string;
+    active?(p: EditorState): boolean
+    render?(p: EditorView): Node
+    icon?: Object;
+    label?: string;
+    title?: 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 class MenuBarEditorView {
+    wrapper: Node;
+    editor: EditorView;
+    props: EditorProps;
+    update(props: EditorProps): void
+    updateState(state: EditorState): void
+    destroy(): void
+
+  }
+
+}

prosemirror-menu/prosemirror-menu-tests.ts

@@ -0,0 +1,3 @@
+import * as menu from 'prosemirror-menu';
+
+let editorView = new menu.MenuBarEditorView();

prosemirror-menu/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-menu-tests.ts"
+    ]
+}

prosemirror-model/index.d.ts

@@ -0,0 +1,266 @@
+// Type definitions for prosemirror-model 0.18
+// Project: https://github.com/ProseMirror/prosemirror-model
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+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: Object;
+    marks: Object;
+    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: Object;
+    marks: Object;
+    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
+
+  }
+
+}

prosemirror-model/prosemirror-model-tests.ts

@@ -0,0 +1,3 @@
+import * as model from 'prosemirror-model';
+
+let fragment = new model.Fragment();

prosemirror-model/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-model-tests.ts"
+    ]
+}

prosemirror-state/index.d.ts

@@ -0,0 +1,109 @@
+// Type definitions for prosemirror-state 0.18
+// Project: https://github.com/ProseMirror/prosemirror-state
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+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'
+
+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 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 class PluginKey {
+    constructor(name?: string)
+    get(state: EditorState): Plugin
+    getState(state: EditorState): any
+
+  }
+  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 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
+
+  }
+
+}

prosemirror-state/prosemirror-state-tests.ts

@@ -0,0 +1,4 @@
+import * as state from 'prosemirror-state';
+
+let spec: state.PluginSpec = {};
+let plugin = new state.Plugin(spec);

prosemirror-state/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-state-tests.ts"
+    ]
+}

prosemirror-transform/index.d.ts

@@ -0,0 +1,120 @@
+// Type definitions for prosemirror-transform 0.18
+// Project: https://github.com/ProseMirror/prosemirror-transform
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+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
+
+}

prosemirror-transform/prosemirror-transform-tests.ts

@@ -0,0 +1,3 @@
+import * as transform from 'prosemirror-transform';
+
+let stepmap = new transform.StepMap([]);

prosemirror-transform/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-transform-tests.ts"
+    ]
+}

prosemirror-view/index.d.ts

@@ -0,0 +1,100 @@
+// Type definitions for prosemirror-view 0.18
+// Project: https://github.com/ProseMirror/prosemirror-view
+// Definitions by: David Hahn <https://github.com/davidka>
+// Definitions: https://github.com/DefinitelyTyped/DefinitelyTyped
+
+
+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
+
+  }
+
+}

prosemirror-view/prosemirror-view-tests.ts

@@ -0,0 +1,3 @@
+import * as view from 'prosemirror-view';
+
+let decoration = new view.Decoration();

prosemirror-view/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-view-tests.ts"
+    ]
+}