diff --git a/tinymce/index.d.ts b/tinymce/index.d.ts
index f760671a8e..b82f90a46e 100644
--- a/tinymce/index.d.ts
+++ b/tinymce/index.d.ts
@@ -5,40 +5,1425 @@
 
 // Work In Progress
 
-declare namespace TinyMCE {
-  export interface Observable {
-    off: (name?: string, callback?: () => void) => any;
-    on: (name: string, callback: () => void) => any;
-    fire: (name: string, args?: any, bubble?: boolean) => Event;
+declare namespace TinyMce {
+
+  export interface Static extends TinyMce.EditorManager {
+
+    DOM: TinyMce.dom.DOMUtils;
+
+    PluginManager: TinyMce.AddOnManager;
+
+    ScriptLoader: TinyMce.dom.ScriptLoader;
+
+    ThemeManager: TinyMce.AddOnManager;
+
+    create(s: string, p: {}, root?: {}): void;
+
+    createNS(n: string, o: {}): {};
+
+    each(o: {}, cb: () => void, s?: {}): void;
+
+    explode(s: string, d: string): void;
+
+    grep(a: any[], f: () => void): any[];
+
+    inArray(item: any, arr: any[]): number;
+
+    is(obj: {}, type?: string): boolean;
+
+    isArray(obj: {}): boolean;
+
+    makeMap(items: any[], delim?: string, map?: {}): {};
+
+    map(array: any[], callback: () => void): any[];
+
+    resolve(n: string, o?: {}): {};
+
+    toArray(obj: {}): any[];
+
+    trim(s: string): string;
+
+    walk(o: {}, f: () => void, n?: string, s?: string): void;
   }
 
-  export interface Editor extends Observable {
-    destroy: (automatic: boolean) => void;
-    remove: () => void;
-    hide: () => void;
-    show: () => void;
-    getContent: (args?: any) => string;
-    setContent: (content: string, args?: any) => string;
-    focus: (skip_focus?: boolean) => void;
+  export interface Settings {
+
+    auto_focus?: string;
+
+    cache_suffix?: string;
+
+    content_security_policy?: string;
+
+    external_plugins?: {};
+
+    hidden_input?: boolean;
+
+    init_instance_callback?: (editor: TinyMce.Editor) => void;
+
+    plugins?: string | string[];
+
+    selector?: string;
+
+    setup?: (edtor: TinyMce.Editor) => void;
+
+    target?: Element;
+
+    color_picker_callback?: (callback: (hexColor: string) => void, value: string) => void;
+
+    elementpath?: boolean;
+
+    event_root?: boolean;
+
+    fixed_toolbar_container?: string;
+
+    height?: number;
+
+    inline?: boolean;
+
+    insert_button_items?: string;
+
+    insert_toolbar?: string;
+
+    max_height?: number;
+
+    max_width?: number;
+
+    menu?: settings.Menu;
+
+    menubar?: string | boolean;
+
+    min_height?: number;
+
+    min_width?: number;
+
+    preview_styles?: boolean | string;
+
+    removed_menuitems?: string;
+
+    resize?: boolean | string;
+
+    selection_toolbar?: string;
+
+    skin_url?: string;
+
+    skin?: string;
+
+    statusbar?: boolean;
+
+    theme_url?: string;
+
+    theme?: string;
+
+    toolbar?: boolean | string | string[];
+
+    width?: number;
+
+    body_class?: string;
+
+    body_id?: string;
+
+    content_css?: string;
+
+    content_style?: string;
+
+    visual_anchor_class?: string;
+
+    visual_table_class?: string;
+
+    visual?: boolean;
+
+    allow_conditional_comments?: boolean;
+
+    allow_html_in_named_anchor?: boolean;
+
+    allow_unsafe_link_target?: boolean;
+
+    convert_fonts_to_spans?: boolean;
+
+    custom_elements?: string;
+
+    doctype?: string;
+
+    element_format?: string;
+
+    encoding?: string;
+
+    entities?: string;
+
+    entity_encoding?: string;
+
+    extended_valid_elements?: string;
+
+    fix_list_elements?: boolean;
+
+    force_hex_style_colors?: boolean;
+
+    forced_root_block?: string;
+
+    forced_root_block_attrs?: {};
+
+    invalid_elements?: string;
+
+    invalid_styles?: string | {};
+
+    keep_styles?: boolean;
+
+    protect?: RegExp[];
+
+    remove_trailing_brs?: boolean;
+
+    schema?: string;
+
+    valid_children?: string;
+
+    valid_classes?: string | {};
+
+    valid_elements?: string;
+
+    valid_styles?: {};
+
+    block_formats?: string;
+
+    font_formats?: string;
+
+    fontsize_formats?: string;
+
+    formats?: {};
+
+    removeFormat?: Array<{}>;
+
+    indentation?: string;
+
+    style_formats?: Array<{}>;
+
+    style_formats_autohide?: boolean;
+
+    style_formats_merge?: boolean;
+
+    browser_spellcheck?: boolean;
+
+    gecko_spellcheck?: boolean;
+
+    automatic_uploads?: boolean;
+
+    file_browser_callback?: (field_name: string, url: string, type: string, win: Window) => void;
+
+    file_browser_callback_types?: string;
+
+    file_picker_callback?: (callback: (filename: string, metadata: {}) => void, valud: string, meta: {}) => void;
+
+    file_picker_types?: string;
+
+    images_dataimg_filter?: (img: any) => void;
+
+    images_reuse_filename?: boolean;
+
+    images_upload_base_path?: string;
+
+    images_upload_credentials?: boolean;
+
+    images_upload_handler?: (blobInfo: any, success: (msg: string) => void, failure: (msg: string) => void) => void;
+
+    images_upload_url?: string;
+
+    directionality?: string;
+
+    language?: string;
+
+    language_url?: string;
+
+    allow_script_urls?: boolean;
+
+    convert_urls?: boolean;
+
+    document_base_url?: string;
+
+    relative_urls?: boolean;
+
+    remove_script_host?: boolean;
+
+    urlconverter_callback?: (url: string, node: HTMLElement, on_save: boolean, name: string) => void;
+
+    anchor_bottom?: string;
+
+    anchor_top?: string;
+
+    br_in_pre?: boolean;
+
+    custom_undo_redo_levels?: number;
+
+    end_container_on_empty_block?: boolean;
+
+    nowrap?: boolean;
+
+    object_resizing?: boolean | string;
+
+    type_ahead_urls?: boolean;
+
+  }
+
+  export namespace settings {
+
+    export interface Menu {
+      file: MenuItem;
+      edit: MenuItem;
+      insert: MenuItem;
+      view: MenuItem;
+      format: MenuItem;
+      table: MenuItem;
+      tools: MenuItem;
+    }
+
+    export interface MenuItem {
+      title: string;
+      items: string;
+    }
+  }
+
+  export interface AddOnManager {
+
+    add(id: string, addOn: (editor: TinyMce.Editor, url: string) => void): Theme | Plugin;
+
+    addComponents(pluginName: string, scripts: string[]): void;
+
+    get(name: string): Theme | Plugin;
+
+    load(name: string, addOnUrl: string, success?: () => void, scope?: {}, failure?: () => void): void;
+
+    requireLangPack(name: string, languages?: string): void;
+  }
+
+  export interface Editor extends util.Observable {
+
+    $: dom.DomQuery;
+
+    baseURI: util.URI;
+
+    contentCSS: string[];
+
+    contentStyles: string[];
+
+    documentBaseURI: util.URI;
+
+    dom: dom.DOMUtils;
+
+    formatter: Formatter;
+
+    id: string;
+
+    initialized: boolean;
+
+    notificationManager: notificationManager;
+
+    parser: html.DomParser;
+
+    schema: html.Schema;
+
+    selection: dom.Selection;
+
+    serializer: dom.Serializer;
+
+    settings: Settings;
+
+    theme: Theme;
+
     undoManager: UndoManager;
-    settings: any;
-    getDoc: () => Document;
-    editorUpload: any;
+
+    WindowManager: WindowManager;
+
+    addButton(name: string, settings: {}): void;
+
+    addCommand(name: string, callback: (ui: boolean, value: {}) => boolean, scope?: {}): void;
+
+    addContextToolbar(predicate: () => void, items: string): void;
+
+    addMenuItem(name: string, settings: {}): void;
+
+    addQueryStateHandler(name: string, callback: () => boolean, scope?: {}): void;
+
+    addQueryValueHandler(name: string, callback: () => {}, scope?: {}): void;
+
+    addShortcut(pattern: string, desc: string, cmdFunc: string, sc?: {}): boolean;
+
+    addSidebar(name: string, settings: {}): void;
+
+    addVisual(elm?: Element): void;
+
+    convertURL(url: string, name: string, elm: string): string;
+
+    destroy(automatic?: boolean): void;
+
+    execCallback(name: string): {};
+
+    execCommand(cmd: string, ui: boolean, value?: any, args?: {}): void;
+
+    focus(skipFocus: boolean): void;
+
+    getBody(): HTMLBodyElement;
+
+    getContainer(): Element;
+
+    getContent(args?: {}): string;
+
+    getContentAreaContainer(): Element;
+
+    getDoc(): Document;
+
+    getElement(): Element;
+
+    getLang(name: string, defaultVal?: string): void;
+
+    getParam(name: string, defaultVal?: string, type?: string): string;
+
+    getWin(): Window;
+
+    hasEventListeners(name: string): boolean;
+
+    hide(): void;
+
+    init(): void;
+
+    insertContent(content: string, args?: {}): void;
+
+    isDirty(): boolean;
+
+    isHidden(): boolean;
+
+    load(args?: {}): string;
+
+    nodeChanged(args?: {}): void;
+
+    queryCommandState(cmd: string): boolean;
+
+    queryCommandSupported(cmd: string): boolean;
+
+    queryCommandValue(cmd: string): {};
+
+    remove(): void;
+
+    render(): void;
+
+    save(args: {}): string;
+
+    setContent(content: string, args?: {}): string;
+
+    setDirty(state: boolean): void;
+
+    setMode(mode: string): void;
+
+    setProgressState(state: boolean, time: number): boolean;
+
+    show(): void;
+
+    translate(text: string): string;
+
+    uploadImages(callback: () => void): Promise<any>;
+  }
+
+  export interface EditorCommands {
+
+    addCommands(command_list: {}, type?: string): void;
+
+    execCommand(command: string, ui?: boolean, value?: {}, args?: {}): boolean;
+
+    queryCommandState(command: string): boolean | number;
+
+    queryCommandSupported(command: string): boolean;
+
+    queryCommandValue(command: string): {};
+  }
+
+  export interface EditorManager extends util.Observable {
+
+    $: dom.DomQuery;
+
+    activeEditor: TinyMce.Editor;
+
+    baseURI: TinyMce.util.URI;
+
+    baseURL: string;
+
+    documentBaseURL: string;
+
+    editors: TinyMce.Editor[];
+
+    i18n: {};
+
+    majorVersion: string;
+
+    minorVersion: string;
+
+    releaseDate: string;
+
+    suffix: string;
+
+    add(editor: TinyMce.Editor): TinyMce.Editor;
+
+    addI18n(code: string, items: {}): void;
+
+    createEditor(id: string, settings: {}): TinyMce.Editor;
+
+    execCommand(cmd: string, ui?: boolean, value?: string): boolean;
+
+    get(id: string): TinyMce.Editor;
+
+    init(settings: Settings): Promise<Editor>;
+
+    overrideDefaults(defaultSettings: {}): void;
+
+    remove(selector: TinyMce.Editor): TinyMce.Editor;
+
+    setActive(editor: TinyMce.Editor): void;
+
+    translate(text: string): string;
+
+    triggerSave(): void;
+  }
+
+  export interface Env {
+
+    android: boolean;
+
+    ceFalse: boolean;
+
+    contentEditable: boolean;
+
+    documentMode: boolean;
+
+    fileApi: boolean;
+
+    gecko: boolean;
+
+    iOS: boolean;
+
+    ie: boolean;
+
+    mac: boolean;
+
+    noCaretAfter: boolean;
+
+    opera: boolean;
+
+    range: boolean;
+
+    transparentSrc: boolean;
+
+    webKit: boolean;
+  }
+
+  export namespace Events {
+
+    export interface Event {
+
+      type: string;
+
+      target: string;
+
+      isDefaultPrevented(): boolean;
+
+      isImmediatePropagationStopped(): boolean;
+
+      isPropagationStopped(): boolean;
+
+      preventDefault(): void;
+
+      stopImmediatePropagation(): void;
+
+      stopPropagation(): void;
+    }
+
+    export interface FocusBlurEvent extends Event {
+
+      blurredEditor: Editor;
+    }
+
+    export interface ContentEvent extends Event {
+
+      format: string;
+
+      set: boolean;
+
+      content: string;
+    }
+
+    export interface ProcessEvent extends Event {
+
+      content: string;
+
+      forced_root_block: string;
+
+      format: string;
+
+      get: boolean;
+
+      get_inner: boolean;
+
+      node: Node;
+
+      selection: true;
+    }
+
+    export interface NodeChangeEvent extends Event {
+
+      element: Node;
+
+      parents: Node[];
+
+      selectionChange: boolean;
+    }
+
+    export interface UndoRedoEvent extends Event {
+
+      level: {};
+    }
+
+    export interface ChangeEvent extends Event {
+
+      lastLevel: {};
+
+      level: {};
+    }
+
+    export interface CommandEvent extends Event {
+
+      command: string;
+
+      ui: boolean;
+
+      value: string;
+    }
+  }
+
+  export interface FocusManager {
+
+    isEditorUIElement(elm: Element): boolean;
+  }
+
+  export class FocusManager implements FocusManager {
+
+    constructor(editorManager: TinyMce.EditorManager);
+  }
+
+  export interface Formatter {
+
+    apply(name: string, vars?: {}, node?: html.Node): void;
+
+    canApply(name: string): boolean;
+
+    formatChanged(formats: string, callback: () => void, similar: boolean): void;
+
+    get(name?: string): any[] | {};
+
+    getCssText(format: string): string;
+
+    match(name: string, vars?: {}, node?: html.Node): boolean;
+
+    matchAll(names: any[], vars?: {}): any[];
+
+    matchNode(node: html.Node, name: string, vars: {}, similar: boolean): {};
+
+    register(name: {}, format?: {}): void;
+
+    remove(name: string, vars?: {}, node?: html.Node): void;
+
+    toggle(name: string, vars?: {}, node?: html.Node): void;
+
+    unregister(name: string): void;
+  }
+
+  export class Formatter implements Formatter {
+
+    constructor(ed: Editor);
+  }
+
+  export interface Shortcuts {
+
+    add(pattern: string, desc: string, cmdFunc: () => void | string, scope?: {}): boolean;
+
+    remove(pattern: string): boolean;
+  }
+
+  export interface Theme {
+
+    renderUI(obj: {}): {};
   }
 
   export interface UndoManager {
-    undo: () => any;
-    clear: () => void;
-    hasUndo: () => boolean;
+
+    add(level?: {}, event?: DocumentEvent): {};
+
+    beforeChange(): void;
+
+    clear(): void;
+
+    extra(callback1: () => void, callback2: () => void): void;
+
+    hasRedo(): boolean;
+
+    hasUndo(): boolean;
+
+    redo(): {};
+
+    transact(callback: () => void): {};
+
+    undo(): {};
   }
 
-  export interface Static extends Observable {
-    init: (settings: any) => void;
-    execCommand: (c: string, u: boolean, v: string) => boolean;
-    activeEditor: Editor;
-    get: (id: string) => Editor;
-    triggerSave: () => void;
+  export interface WindowManager {
+
+    alert(message: string, callback: () => void, scope?: {}): void;
+
+    close(): void;
+
+    confirm(message: string, callback: () => void, scope?: {}): void;
+
+    getParams(): {};
+
+    getWindows(): Window[];
+
+    open(args: {}, params: {}): void;
+
+    setParams(params: {}): void;
+  }
+
+  export interface notificationManager {
+
+    close(): void;
+
+    getNotifications(): Array<{}>;
+
+    open(args?: {}): void;
+  }
+
+  export namespace dom {
+
+    export interface BookmarkManager {
+
+      getBookmark(type?: number, normalized?: boolean): {};
+
+      isBookmarkNode(node: HTMLElement): boolean;
+
+      moveToBookmark(bookmark: {}): boolean;
+    }
+
+    export interface DOMUtils {
+
+      add<T>(parentElm: string, name: string, attrs?: {}, html?: string, create?: boolean): Element | T[];
+
+      addClass<T>(elm: string, cls: string): string | T[];
+
+      addStyle(cssText: string): void;
+
+      bind(target: Element, name: string, func: () => void, scope?: {}): () => void;
+
+      create(name: string, attrs?: {}, html?: string): Element;
+
+      createFragment(html: string): DocumentFragment;
+
+      createHTML(name: string, attrs?: {}, html?: string): string;
+
+      createRng(): Range;
+
+      decode(s: string): string;
+
+      destroy(): void;
+
+      encode(text: string): string;
+
+      findCommonAncestor(a: Element, b: Element): Element;
+
+      fire(target: Node, name: string, evt: {}): Event;
+
+      get(n: string): Element;
+
+      getAttrib(elm: string, name: string, defaultVal: string): string;
+
+      getAttribs(elm?: HTMLElement): NodeList;
+
+      getNext(node: Node, selector: string): Node;
+
+      getOuterHTML(elm: string): string;
+
+      getParent(node: Node, selector: () => void, root?: Node): Node;
+
+      getParents<T>(node: Node, selector: () => void, root?: Node): T[];
+
+      getPos(elm: Element, rootElm?: Element): {};
+
+      getPrev(node: Node, selector: string): Node;
+
+      getRect(elm: Element): {};
+
+      getRoot(): Element;
+
+      getSize(elm: Element): {};
+
+      getStyle(elm: string, name: string, computed: boolean): string;
+
+      getViewPort(win?: Window): {};
+
+      hasClass(elm: string, cls: string): boolean;
+
+      hide(elm: string): void;
+
+      insertAfter<T>(node: Element, referenceNode: Element): Element | T[];
+
+      is(elm: Node, selector: string): void;
+
+      isBlock(node: Node): boolean;
+
+      isEmpty(elements?: {}): boolean;
+
+      isHidden(elm: string): boolean;
+
+      loadCSS(url: string): void;
+
+      nodeIndex(node: Node, normalized?: boolean): number;
+
+      parseStyle(cssText: string): {};
+
+      remove<T>(node: string, keepChildren?: boolean): Element | T[];
+
+      removeAllAttribs(e: Element): void;
+
+      removeClass<T>(elm: string, cls: string): string | T[];
+
+      rename(elm: Element, name: string): Element;
+
+      replace(newElm: Element, oldElm: Element, keepChildren?: boolean): void;
+
+      run<T>(elm: string, func: () => void, scope?: {}): {} | T[];
+
+      select<T>(selector: string, scope?: {}): T[];
+
+      serializeStyle(styles: {}, name?: string): string;
+
+      setAttrib(elm: Element, name: string, value: string): void;
+
+      setAttribs(elm: Element, attrs: {}): void;
+
+      setHTML(elm: Element, html: string): void;
+
+      setOuterHTML(elm: Element, html: {}): void;
+
+      setStyle(elm: string, name: string, value: string): void;
+
+      setStyles(elm: Element, styles: {}): void;
+
+      show(elm: string): void;
+
+      split(parentElm: Element, splitElm: Element, replacementElm?: Element): Element;
+
+      toHex(rgbVal: string): string;
+
+      toggleClass(elm: Element, cls: string, state?: string): void;
+
+      unbind<T>(target: Element, name: string, func: () => void): boolean | T[];
+
+      uniqueId(prefix?: string): string;
+    }
+
+    export class DOMUtils implements DOMUtils {
+
+      constructor(doc: Document, settings?: {});
+    }
+
+    export interface DomQuery {
+
+      add<T>(items: T[], sort?: boolean): DomQuery;
+
+      addClass(className: string): DomQuery;
+
+      after(content: string): DomQuery;
+
+      append(content: string): DomQuery;
+
+      appendTo(val: string): DomQuery;
+
+      attr(name: string, value?: string): DomQuery | string;
+
+      before(content: string): DomQuery;
+
+      children(node: Element | string): DomQuery;
+
+      clone(): DomQuery;
+
+      closest(selector: string): DomQuery;
+
+      contents(node: Element | string): DomQuery;
+
+      css(name: string, value?: string): DomQuery | string;
+
+      each(callback: () => void): DomQuery;
+
+      each(obj: {}, callback: () => void): void;
+
+      empty(): DomQuery;
+
+      eq(index: number): DomQuery;
+
+      extend(target: {}, object: {}): {};
+
+      filter(selector: string): DomQuery;
+
+      find(selector: string): DomQuery;
+
+      first(): DomQuery;
+
+      grep<T>(array: T[], callback: () => void): T[];
+
+      hasClass(className: string): boolean;
+
+      hide(): DomQuery;
+
+      html(value?: string): DomQuery | string;
+
+      inArray<T>(item: {}, array: T[]): number;
+
+      is(selector: string): boolean;
+
+      isArray(array: {}): boolean;
+
+      last(): DomQuery;
+
+      makeArray<T>(object: {}): T[];
+
+      next(node: Element | string): DomQuery;
+
+      nextUntil(node: Element | string, until: string): DomQuery;
+
+      off(name?: string, callback?: () => void): DomQuery;
+
+      offset(offset?: {}): {} | DomQuery;
+
+      on(name: string, callback: () => void): DomQuery;
+
+      parent(node: Element | string): DomQuery;
+
+      parents(node: Element | string): DomQuery;
+
+      parentsUntil(node: Element | string, until: string): DomQuery;
+
+      prepend(content: string): DomQuery;
+
+      prependTo(val: string): DomQuery;
+
+      prev(node: Element | string): DomQuery;
+
+      prevUntil(node: Element | string, until: string): DomQuery;
+
+      remove(): DomQuery;
+
+      removeAttr(name: string): DomQuery | string;
+
+      removeClass(className: string): DomQuery;
+
+      replaceWith(content: string): DomQuery;
+
+      show(): DomQuery;
+
+      slice(start: number, end?: number): DomQuery;
+
+      text(value?: string): DomQuery | string;
+
+      toArray<T>(): T[];
+
+      toggleClass(className: string, state?: boolean): DomQuery;
+
+      trigger(name: string): DomQuery;
+
+      trim(str: string): string;
+
+      unwrap(): DomQuery;
+
+      wrap(content: string): DomQuery;
+
+      wrapAll(content: string): DomQuery;
+
+      wrapInner(content: string): DomQuery;
+    }
+
+    export class DomQuery implements DomQuery {
+
+      constructor(selector?: string, context?: Document);
+    }
+
+    export interface EventUtils {
+
+      bind(target: {}, names: string, callback: () => void, scope: {}): () => void;
+
+      clean(target: {}): EventUtils;
+
+      fire(target: {}, name: string, args?: {}): EventUtils;
+
+      unbind(target: {}, names?: string, callback?: () => void): EventUtils;
+    }
+
+    export interface RangeUtils {
+
+      compareRanges(rng1: Range, rng2: Range): boolean;
+
+      getCaretRangeFromPoint(clientX: number, clientY: number, doc: Document): Range;
+    }
+
+    export interface ScriptLoader {
+
+      add(url: string, success?: () => void, scope?: {}, failure?: () => void): void;
+
+      isDone(url: string): boolean;
+
+      load(url: string, callback1?: () => void, callback2?: () => void): void;
+
+      loadQueue(success?: () => void, failure?: () => void, scope?: {}): void;
+
+      loadScripts(scripts: string[], callback1?: () => void, scope?: {}, callback2?: () => void): void;
+
+      markDone(url: string): void;
+    }
+
+    export interface Selection {
+
+      collapse(toStart?: boolean): void;
+
+      getBookmark(type?: number, normalized?: boolean): {};
+
+      getContent(args?: {}): string;
+
+      getEnd(real?: boolean): Element;
+
+      getNode(): Element;
+
+      getRng(w3c: boolean): Range;
+
+      getSel(): Selection;
+
+      getStart(real?: boolean): Element;
+
+      isCollapsed(): boolean;
+
+      moveToBookmark(bookmark: {}): boolean;
+
+      select(node: Element, content?: boolean): Element;
+
+      selectorChanged(selector: string, callback: () => void): void;
+
+      setContent(content: string, args?: {}): void;
+
+      setCursorLocation(node?: html.Node, offset?: number): void;
+
+      setNode(elm: Element): Element;
+
+      setRng(rng: Range, forward?: boolean): void;
+    }
+
+    export class Selection implements Selection {
+
+      constructor(dom: DOMUtils, win: Window, editor: Editor, serializer: Serializer);
+    }
+
+    export interface Serializer {
+
+      addAttributeFilter(callback: () => void): void;
+
+      addNodeFilter(callback: () => void): void;
+
+      addRules(rules: string): void;
+
+      addTempAttr(name: string): void;
+
+      serialize(node: HTMLElement, args: {}): void;
+
+      setRules(rules: string): void;
+
+    }
+
+    export class Serializer implements Serializer {
+
+      constructor(settings: {}, editor?: Editor);
+    }
+
+    export interface TreeWalker {
+
+      current(): html.Node;
+
+      next(): html.Node;
+
+      prev(): html.Node;
+    }
+  }
+
+  export class TreeWalker implements TreeWalker {
+
+    constructor(startNode: html.Node, rootNode: html.Node);
+  }
+
+  export namespace geom {
+
+    export interface Rect {
+
+      clamp(rect: Rect, clampRect: Rect, fixedSize: boolean): Rect;
+
+      create(x: number, y: number, w: number, h: number): Rect;
+
+      findBestRelativePosition(rect: Rect, targetRect: Rect, constrainRect: Rect, rels: any[]): void;
+
+      fromClientRect(clientRect: ClientRect): Rect;
+
+      inflate(rect: Rect, w: number, h: number): Rect;
+
+      intersect(rect: Rect, cropRect: Rect): Rect;
+
+      relativePosition(rect: Rect, targetRect: Rect, rel: string): void;
+    }
+  }
+
+  export namespace html {
+
+    export interface DomParser {
+
+      addAttributeFilter(attributes: string, callback: () => void): void;
+
+      addNodeFilter(attributes: string, callback: () => void): void;
+
+      filterNode(node: TinyMce.html.Node): TinyMce.html.Node;
+
+      parse(html: string, args?: {}): TinyMce.html.Node;
+    }
+
+    export class DomParser implements DomParser {
+
+      constructor(settings: {}, schema: TinyMce.html.Schema);
+    }
+
+    export interface Entities {
+
+      decode(text: string): string;
+
+      encodeAllRaw(text: string): string;
+
+      encodeNamed(text: string, attr?: boolean, entities?: {}): string;
+
+      encodeNumeric(text: string, attr?: boolean): string;
+
+      encodeRaw(text: string, attr?: boolean): string;
+
+      getEncodeFunc(name: string, entities?: string): () => void;
+    }
+
+    export interface Node {
+
+      append(node: TinyMce.html.Node): TinyMce.html.Node;
+
+      attr(name: string, value?: string): string | TinyMce.html.Node;
+
+      clone(): TinyMce.html.Node;
+
+      create(name: string, attrs: {}): void;
+
+      empty(): TinyMce.html.Node;
+
+      getAll(name: string): TinyMce.html.Node[];
+
+      insert(node: TinyMce.html.Node, ref_node: TinyMce.html.Node, before?: boolean): TinyMce.html.Node;
+
+      isEmpty(elements: {}): boolean;
+
+      remove(): TinyMce.html.Node;
+
+      replace(node: TinyMce.html.Node): TinyMce.html.Node;
+
+      unwrap(): void;
+
+      walk(prev?: boolean): TinyMce.html.Node;
+
+      wrap(wrapperNode: TinyMce.html.Node): TinyMce.html.Node;
+    }
+
+    export class Node implements Node {
+
+      constructor(name: string, type: number);
+    }
+
+    export interface SaxParser {
+
+      parse(html: string): void;
+    }
+
+    export class SaxParser implements SaxParser {
+
+      constructor(settings: {}, schema: TinyMce.html.Schema);
+    }
+
+    export interface Schema {
+
+      addCustomElements(custom_elements: string): void;
+
+      addValidChildren(valid_children: string): void;
+
+      addValidElements(valid_elements: string): void;
+
+      getBlockElements(): {};
+
+      getBoolAttrs(): {};
+
+      getCustomElements(): {};
+
+      getElementRule(name: string): {};
+
+      getInvalidStyles(): void;
+
+      getMoveCaretBeforeOnEnterElements(): {};
+
+      getNonEmptyElements(): {};
+
+      getSelfClosingElements(): {};
+
+      getShortEndedElements(): {};
+
+      getSpecialElements(): {};
+
+      getTextBlockElements(): {};
+
+      getTextInlineElements(): {};
+
+      getValidClasses(): void;
+
+      getValidStyles(): void;
+
+      getWhiteSpaceElements(): {};
+
+      isValid(name: string, attr?: string): boolean;
+
+      isValidChild(name: string, child: string): boolean;
+
+      setValidElements(valid_elements: string): void;
+    }
+
+    export class Schema implements Schema {
+
+        constructor(settings: {});
+    }
+
+    export interface Serializer {
+
+      serialize(node: TinyMce.html.Node): string;
+    }
+
+    export class Serializer implements Serializer {
+
+      constructor(settings: {}, schema: TinyMce.html.Schema);
+    }
+
+    export interface Styles {
+
+      parse(css: string): {};
+
+      serialize(styles: {}, elementName: string): string;
+
+      toHex(color: string): string;
+    }
+
+    export interface Writer {
+
+      cdata(text: string): void;
+
+      doctype(text: string): void;
+
+      end(name: string): void;
+
+      getContent(): string;
+
+      pi(name: string, text: string): void;
+
+      reset(): void;
+
+      start(name: string, attrs?: any[], empty?: boolean): void;
+
+      text(text: string, raw: boolean): void;
+    }
+  }
+
+  export class Writer implements Writer {
+
+    constructor(settings: {});
+  }
+
+  export namespace util {
+
+    export interface Color {
+
+      parse(value: {}): TinyMce.util.Color;
+
+      toHex(): string;
+
+      toHsv(): {};
+
+      toRgb(): {};
+    }
+
+    export class Color implements Color {
+
+      constructor(value: string | {});
+    }
+
+    export interface Delay {
+
+      clearInterval(interval: number): void;
+
+      clearTimeout(timeout: number): void;
+
+      debounce(callback: () => void, time: number): () => void;
+
+      requestAnimationFrame(callback: () => void, element?: HTMLElement): void;
+
+      setEditorInterval(callback: () => void, time: number): number;
+
+      setEditorTimeout(editor: TinyMce.Editor, callback: () => void, time: number): number;
+
+      setInterval(callback: () => void, time: number): number;
+
+      setTimeout(callback: () => void, time: number): number;
+    }
+
+    export interface EventDispatcher {
+
+      fire(name: string, args?: {}): {};
+
+      has(name: string): boolean;
+
+      isNative(name: string): boolean;
+
+      off(name: string, callback?: () => void): {};
+
+      on(name: string, callback: () => void, first?: boolean): {};
+
+      once(name: string, callback: () => void, first: boolean): {};
+    }
+
+    export interface i18n {
+
+      rtl: boolean;
+
+      add(code: string, items: Array<{}>): void;
+
+      getCode(): string;
+
+      setCode(newCode: string): void;
+
+      translate(text: string): string;
+    }
+
+    export interface JSON {
+
+      parse(s: string): {};
+
+      serialize(obj: {}, quote?: string): string;
+    }
+
+    export interface JSONRequest {
+
+      send(args: {}): void;
+
+      sendRPC(o: {}): void;
+    }
+
+    export interface LocalStorage {
+
+      length: number;
+
+      clear(): void;
+
+      getItem(key: string): string;
+
+      key(index: number): string;
+
+      removeItem(key: string): void;
+
+      setItem(key: string, value: string): void;
+    }
+
+    export interface Observable {
+
+      fire(name: string, args?: {}, bubble?: boolean): {};
+
+      hasEventListeners(name: string): boolean;
+
+      off(name?: string, callback?: () => void): {};
+
+      on(name: string, callback: (event: any) => void, first?: boolean): {};
+
+      once(name: string, callback: (event: any) => void): {};
+    }
+
+    export interface Tools {
+
+      create(s: string, p: {}, root?: {}): void;
+
+      createNS(n: string, o?: {}): {};
+
+      each(o: {}, cb: () => void, s?: {}): void;
+
+      explode(s: string, d: string): void;
+
+      grep<T>(a: T[], f: () => void): T[];
+
+      inArray<T>(item: T, arr: T[]): number;
+
+      is(obj: {}, type: string): boolean;
+
+      isArray(obj: {}): boolean;
+
+      makeMap<T>(items: T[], delim?: string, map?: {}): {};
+
+      map<T, S>(array: T[], callback: (c: T) => S): S[];
+
+      resolve(n: string, o?: {}): {};
+
+      toArray<T>(obj: {}): T[];
+
+      trim(s: string): string;
+
+      walk(o: {}, f: () => void, n?: string, s?: string): void;
+    }
+
+    export interface URI {
+
+      getURI(noProtoHost: boolean): URI;
+
+      isSameOrigin(uri: TinyMce.util.URI): boolean;
+
+      setPath(path: string): void;
+
+      toAbsPath(base: string, path: string): void;
+
+      toAbsolute(uri: string, noHost: boolean): string;
+
+      toRelPath(base: string, path: string): void;
+
+      toRelative(uri: string): string;
+    }
+
+    export class URI implements URI {
+
+      constructor(url: string, settings?: {});
+    }
+
+    export interface XHR {
+
+      fire(name: string, args?: {}, bubble?: boolean): {};
+
+      hasEventListeners(name: string): boolean;
+
+      off(name?: string, callback?: () => void): {};
+
+      on(name: string, callback: () => void, first?: boolean): {};
+
+      once(name: string, callback: () => void): {};
+
+      send(settings: {}): void;
+    }
+
   }
 }
 
-declare var tinymce: TinyMCE.Static;
+declare var tinymce: TinyMce.Static;
diff --git a/tinymce/tinymce-tests.ts b/tinymce/tinymce-tests.ts
index 3b3f3386f1..18dd5cfbc7 100644
--- a/tinymce/tinymce-tests.ts
+++ b/tinymce/tinymce-tests.ts
@@ -1,12 +1,17 @@
 tinymce.init(
   {
-    selector: '.tinymce-editable',
-    height: 145,
+    selector: 'textarea',
+    height: 500,
+    menubar: false,
     plugins: [
-      'autolink table contextmenu paste code link textcolor colorpicker image imagetools'
+      'advlist autolink lists link image charmap print preview anchor',
+      'searchreplace visualblocks code fullscreen',
+      'insertdatetime media table contextmenu paste code'
     ],
-    menubar: 'edit insert table tools',
-    toolbar: 'undo redo | styleselect bold italic forecolor backcolor | alignleft aligncenter alignright alignjustify | bullist numlist | link image',
-    content_css: 'page.css'
+    toolbar: 'undo redo | insert | styleselect | bold italic | alignleft aligncenter alignright alignjustify | bullist numlist outdent indent | link image',
+    content_css: '//www.tinymce.com/css/codepen.min.css'
   }
-);
\ No newline at end of file
+);
+
+
+let t = new TinyMce.util.Color('#FFFFFF');