diff --git a/packages/core/src/browser/quick-open/quick-open-action-provider.ts b/packages/core/src/browser/quick-open/quick-open-action-provider.ts
index f666bc5da9481..565f0c79ae485 100644
--- a/packages/core/src/browser/quick-open/quick-open-action-provider.ts
+++ b/packages/core/src/browser/quick-open/quick-open-action-provider.ts
@@ -82,15 +82,7 @@ export abstract class QuickOpenBaseAction implements QuickOpenAction {
         this.options.checked = value;
     }
 
-    get radio(): boolean {
-        return this.options.radio || false;
-    }
-
-    set radio(value: boolean) {
-        this.options.radio = value;
-    }
-
-    abstract run(item?: QuickOpenItem): PromiseLike<void>;
+    abstract run(item?: QuickOpenItem): Promise<void>;
 
     dispose(): void { }
 }
diff --git a/packages/core/src/common/quick-open-model.ts b/packages/core/src/common/quick-open-model.ts
index 14cc9c5aaf75a..c4aa973e38237 100644
--- a/packages/core/src/common/quick-open-model.ts
+++ b/packages/core/src/common/quick-open-model.ts
@@ -121,11 +121,10 @@ export interface QuickOpenActionOptions {
     class?: string | undefined;
     enabled?: boolean;
     checked?: boolean;
-    radio?: boolean;
 }
 
 export interface QuickOpenAction extends QuickOpenActionOptions, Disposable {
-    run(item?: QuickOpenItem): PromiseLike<void>;
+    run(item?: QuickOpenItem): Promise<void>;
 }
 
 export enum QuickTitleButtonSide {
diff --git a/packages/monaco/src/browser/monaco-command-service.ts b/packages/monaco/src/browser/monaco-command-service.ts
index 982fc76a2b23a..0e8212b6974bf 100644
--- a/packages/monaco/src/browser/monaco-command-service.ts
+++ b/packages/monaco/src/browser/monaco-command-service.ts
@@ -54,7 +54,7 @@ export class MonacoCommandService implements ICommandService {
     async executeCommand(commandId: any, ...args: any[]): Promise<any> {
         const handler = this.commandRegistry.getActiveHandler(commandId, ...args);
         if (handler) {
-            this._onWillExecuteCommand.fire({ commandId });
+            this._onWillExecuteCommand.fire({ commandId, args });
             return handler.execute(...args);
         }
         return this.executeMonacoCommand(commandId, ...args);
diff --git a/packages/monaco/src/browser/monaco-command.ts b/packages/monaco/src/browser/monaco-command.ts
index 54ea049757ea3..8d1d194078ab7 100644
--- a/packages/monaco/src/browser/monaco-command.ts
+++ b/packages/monaco/src/browser/monaco-command.ts
@@ -27,7 +27,9 @@ import { MonacoCommandRegistry, MonacoEditorCommandHandler } from './monaco-comm
 import MenuRegistry = monaco.actions.MenuRegistry;
 import { MonacoCommandService } from './monaco-command-service';
 
-export type MonacoCommand = Command & { delegate?: string };
+// vs code doesn't use iconClass anymore, but icon instead, so some adaptation is required to reuse it on theia side
+export type MonacoIcon = { dark?: monaco.Uri; light?: monaco.Uri } | monaco.theme.ThemeIcon;
+export type MonacoCommand = Command & { icon?: MonacoIcon, delegate?: string };
 export namespace MonacoCommands {
 
     export const UNDO = 'undo';
@@ -68,19 +70,20 @@ export namespace MonacoCommands {
         'editor.action.clipboardCopyAction',
         'editor.action.clipboardPasteAction'
     ]);
-    const iconClasses = new Map<string, string>();
+    const icons = new Map<string, MonacoIcon>();
     for (const menuItem of MenuRegistry.getMenuItems(7)) {
-        // todo
-        if (menuItem.command && menuItem.command.iconClass) {
-            iconClasses.set(menuItem.command.id, menuItem.command.iconClass);
+
+        const commandItem = menuItem.command;
+        if (commandItem && commandItem.icon) {
+            icons.set(commandItem.id, commandItem.icon);
         }
     }
     for (const command of monaco.editorExtensions.EditorExtensionsRegistry.getEditorActions()) {
         const id = command.id;
         if (!EXCLUDE_ACTIONS.has(id)) {
             const label = command.label;
-            const iconClass = iconClasses.get(id);
-            ACTIONS.set(id, { id, label, iconClass });
+            const icon = icons.get(id);
+            ACTIONS.set(id, { id, label, icon });
         }
     }
     for (const keybinding of monaco.keybindings.KeybindingsRegistry.getDefaultKeybindings()) {
@@ -280,7 +283,12 @@ export class MonacoEditorCommandHandlers implements CommandContribution {
 
     protected newKeyboardHandler(action: string): MonacoEditorCommandHandler {
         return {
-            execute: (editor, ...args) => editor.getControl()._modelData.cursor.trigger('keyboard', action, args)
+            execute: (editor, ...args) => {
+                const modelData = editor.getControl()._modelData;
+                if (modelData) {
+                    modelData.cursor.trigger('keyboard', action, args);
+                }
+            }
         };
     }
     protected newCommandHandler(action: string): MonacoEditorCommandHandler {
diff --git a/packages/monaco/src/browser/monaco-editor-provider.ts b/packages/monaco/src/browser/monaco-editor-provider.ts
index 12b0c94ab7d0c..a5961ea88c882 100644
--- a/packages/monaco/src/browser/monaco-editor-provider.ts
+++ b/packages/monaco/src/browser/monaco-editor-provider.ts
@@ -163,7 +163,13 @@ export class MonacoEditorProvider {
      */
     protected suppressMonacoKeybindingListener(editor: MonacoEditor): void {
         let keydownListener: monaco.IDisposable | undefined;
-        for (const listener of editor.getControl()._standaloneKeybindingService._store._toDispose) {
+        const keybindingService = editor.getControl()._standaloneKeybindingService;
+        if (!keybindingService) {
+            console.warn('Cannot suppresses Monaco keydown listener because KeybindingService is not recognized');
+            return;
+        }
+
+        for (const listener of keybindingService._store._toDispose) {
             if ('_type' in listener && listener['_type'] === 'keydown') {
                 keydownListener = listener;
                 break;
@@ -176,6 +182,11 @@ export class MonacoEditorProvider {
 
     protected injectKeybindingResolver(editor: MonacoEditor): void {
         const keybindingService = editor.getControl()._standaloneKeybindingService;
+        if (!keybindingService) {
+            console.warn('Cannot inject Keybinding Resolver because KeybindingService is not recognized');
+            return;
+        }
+
         keybindingService.resolveKeybinding = keybinding => [new MonacoResolvedKeybinding(MonacoResolvedKeybinding.keySequence(keybinding), this.keybindingRegistry)];
         keybindingService.resolveKeyboardEvent = keyboardEvent => {
             const keybinding = new monaco.keybindings.SimpleKeybinding(
@@ -353,8 +364,10 @@ export class MonacoEditorProvider {
     protected installReferencesController(editor: MonacoEditor): void {
         const control = editor.getControl();
         const referencesController = control._contributions['editor.contrib.referencesController'];
-        referencesController._gotoReference = ref => {
-            referencesController._widget.hide();
+        referencesController._gotoReference = async ref => {
+            if (referencesController._widget) {
+                referencesController._widget.hide();
+            }
 
             referencesController._ignoreModelChangeEvent = true;
             const range = monaco.Range.lift(ref.range).collapseToStart();
@@ -385,9 +398,7 @@ export class MonacoEditorProvider {
 
                     const modelPromise = Promise.resolve(model) as any;
                     modelPromise.cancel = () => { };
-                    openedEditor._contributions['editor.contrib.referencesController'].toggleWidget(range, modelPromise, {
-                        getMetaTitle: m => m.references.length > 1 ? ` – ${m.references.length} references` : ''
-                    });
+                    openedEditor._contributions['editor.contrib.referencesController'].toggleWidget(range, modelPromise, false);
                     return;
                 }
 
diff --git a/packages/monaco/src/browser/monaco-quick-open-service.ts b/packages/monaco/src/browser/monaco-quick-open-service.ts
index 44e0fda2545c5..fcfbe88438897 100644
--- a/packages/monaco/src/browser/monaco-quick-open-service.ts
+++ b/packages/monaco/src/browser/monaco-quick-open-service.ts
@@ -421,8 +421,8 @@ export class QuickOpenEntry extends monaco.quickOpen.QuickOpenEntry {
         return this.item.getLabel();
     }
 
-    getAriaLabel(): string | undefined {
-        return this.item.getTooltip();
+    getAriaLabel(): string {
+        return this.item.getTooltip() || '';
     }
 
     getDetail(): string | undefined {
@@ -500,7 +500,7 @@ export class QuickOpenEntryGroup extends monaco.quickOpen.QuickOpenEntryGroup {
 
 }
 
-export class MonacoQuickOpenAction implements monaco.quickOpen.IAction {
+export class MonacoQuickOpenAction implements monaco.editor.IAction {
     constructor(public readonly action: QuickOpenAction) { }
 
     get id(): string {
@@ -527,12 +527,8 @@ export class MonacoQuickOpenAction implements monaco.quickOpen.IAction {
         return this.action.checked || false;
     }
 
-    get radio(): boolean {
-        return this.action.radio || false;
-    }
-
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    run(entry: QuickOpenEntry | QuickOpenEntryGroup): PromiseLike<any> {
+    run(entry: QuickOpenEntry | QuickOpenEntryGroup): Promise<any> {
         return this.action.run(entry.item);
     }
 
@@ -550,7 +546,7 @@ export class MonacoQuickOpenActionProvider implements monaco.quickOpen.IActionPr
     }
 
     // eslint-disable-next-line @typescript-eslint/no-explicit-any
-    getActions(element: any, entry: QuickOpenEntry | QuickOpenEntryGroup): ReadonlyArray<monaco.quickOpen.IAction> {
+    getActions(element: any, entry: QuickOpenEntry | QuickOpenEntryGroup): ReadonlyArray<monaco.editor.IAction> {
         const actions = this.provider.getActions(entry.item);
         return actions.map(action => new MonacoQuickOpenAction(action));
     }
diff --git a/packages/monaco/src/browser/monaco-resolved-keybinding.ts b/packages/monaco/src/browser/monaco-resolved-keybinding.ts
index e7eb37f656816..a5124cf748cef 100644
--- a/packages/monaco/src/browser/monaco-resolved-keybinding.ts
+++ b/packages/monaco/src/browser/monaco-resolved-keybinding.ts
@@ -49,7 +49,7 @@ export class MonacoResolvedKeybinding extends monaco.keybindings.ResolvedKeybind
     }
 
     public getElectronAccelerator(): string | null {
-        if (this.isChord) {
+        if (this.isChord()) {
             // Electron cannot handle chords
             // eslint-disable-next-line no-null/no-null
             return null;
diff --git a/packages/monaco/src/browser/monaco-semantic-highlighting-service.ts b/packages/monaco/src/browser/monaco-semantic-highlighting-service.ts
index 475a1ef8eb23e..aa2116f88c5dd 100644
--- a/packages/monaco/src/browser/monaco-semantic-highlighting-service.ts
+++ b/packages/monaco/src/browser/monaco-semantic-highlighting-service.ts
@@ -131,7 +131,7 @@ export class MonacoSemanticHighlightingService extends SemanticHighlightingServi
         // TODO: why for-of? How to pick the right scope? Is it fine to get the first element (with the narrowest scope)?
         for (const scope of scopes) {
             const tokenTheme = this.tokenTheme();
-            const metadata = tokenTheme.match(undefined, scope);
+            const metadata = tokenTheme.match(monaco.services.LanguageId.Null, scope);
             // Don't use the inlineClassName from the TokenMetadata, because this
             // will conflict with styles used for TM scopes
             // (https://github.com/Microsoft/monaco-editor/issues/1070).
diff --git a/packages/monaco/src/typings/monaco/index.d.ts b/packages/monaco/src/typings/monaco/index.d.ts
index dc7f95823b076..ed94a46c31bd6 100644
--- a/packages/monaco/src/typings/monaco/index.d.ts
+++ b/packages/monaco/src/typings/monaco/index.d.ts
@@ -29,10 +29,12 @@ declare module monaco.editor {
         ariaSummary: string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/services/bulkEditService.ts#L23
     export interface IBulkEditService {
         apply(edit: monaco.languages.WorkspaceEdit): Promise<IBulkEditResult>;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/widget/diffNavigator.ts#L43
     export interface IDiffNavigator {
         readonly ranges: IDiffRange[];
         readonly nextIdx: number;
@@ -40,6 +42,7 @@ declare module monaco.editor {
         _initIdx(fwd: boolean): void;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/widget/diffNavigator.ts#L16
     export interface IDiffRange {
         readonly range: Range;
     }
@@ -54,10 +57,10 @@ declare module monaco.editor {
             }
             resolveKeybinding(keybinding: monaco.keybindings.ChordKeybinding): monaco.keybindings.ResolvedKeybinding[];
             resolveKeyboardEvent(keyboardEvent: monaco.IKeyboardEvent): monaco.keybindings.ResolvedKeybinding;
-        }
+        } | null
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/editor/browser/widget/codeEditorWidget.ts#L107
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/widget/codeEditorWidget.ts#L104
     export interface CommonCodeEditor {
         readonly _commandService: monaco.commands.ICommandService;
         readonly _instantiationService: monaco.instantiation.IInstantiationService;
@@ -67,9 +70,10 @@ declare module monaco.editor {
         }
         readonly _modelData: {
             cursor: ICursor
-        };
+        } | null;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/controller/cursor.ts#L169
     export interface ICursor {
         trigger(source: string, handlerId: string, payload: any): void;
     }
@@ -83,6 +87,7 @@ declare module monaco.editor {
         contextKeyService?: monaco.contextKeyService.IContextKeyService;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/editor/common/editor.ts#L63
     export interface IResourceInput {
         resource: monaco.Uri;
         options?: IResourceInputOptions;
@@ -93,29 +98,23 @@ declare module monaco.editor {
          * Tells the editor to not receive keyboard focus when the editor is being opened. By default,
          * the editor will receive keyboard focus on open.
          */
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/editor/common/editor.ts#L132
         preserveFocus?: boolean;
 
         /**
          * Will reveal the editor if it is already opened and visible in any of the opened editor groups.
          */
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/editor/common/editor.ts#L157
         revealIfVisible?: boolean;
 
         /**
          * Text editor selection.
          */
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/editor/common/editor.ts#L223
         selection?: Partial<monaco.IRange>;
     }
 
-    export interface IEditorReference {
-        getControl(): monaco.editor.CommonCodeEditor;
-    }
-
-    export interface IEditorInput {
-    }
-
-    export interface IEditorOptions {
-    }
-
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/services/codeEditorService.ts#L15
     export interface ICodeEditorService {
         getActiveCodeEditor(): monaco.editor.ICodeEditor | undefined;
         openCodeEditor(input: monaco.editor.IResourceInput, source?: monaco.editor.ICodeEditor, sideBySide?: boolean): Promise<monaco.editor.CommonCodeEditor | undefined>;
@@ -124,10 +123,12 @@ declare module monaco.editor {
         resolveDecorationOptions(typeKey: string, writable: boolean): IModelDecorationOptions;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/lifecycle.ts#L209
     export interface IReference<T> extends monaco.IDisposable {
         readonly object: T;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/resolverService.ts#L14
     export interface ITextModelService {
         /**
          * Provided a resource URI, it will return a model reference
@@ -141,13 +142,16 @@ declare module monaco.editor {
         registerTextModelContentProvider(scheme: string, provider: ITextModelContentProvider): monaco.IDisposable;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/resolverService.ts#L34
     export interface ITextModelContentProvider {
         /**
          * Given a resource, return the content of the resource as IModel.
          */
-        provideTextContent(resource: monaco.Uri): Promise<monaco.editor.IModel>;
+        provideTextContent(resource: monaco.Uri): Promise<monaco.editor.IModel | null> | null;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/resolverService.ts#L42 &&
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/editor/common/editor.ts#L9
     export interface ITextEditorModel {
         onDispose: monaco.IEvent<void>;
         /**
@@ -165,11 +169,12 @@ declare module monaco.editor {
         textEditorModel: monaco.editor.IModel;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/browser/contextmenu.ts#L25
     export interface IContextMenuDelegate {
         /**
          * Returns with an HTML element or the client coordinates as the anchor of the context menu to open.
          */
-        getAnchor(): HTMLElement | { x: number; y: number; };
+        getAnchor(): HTMLElement | { x: number; y: number; width?: number; height?: number };
 
         /**
          * Returns the actions for the menu
@@ -182,18 +187,18 @@ declare module monaco.editor {
         onHide(wasCancelled: boolean): void
     }
 
-    export interface IAction {
-        id: string;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/actions.ts#L25
+    export interface IAction extends IDisposable {
+        readonly id: string;
         label: string;
         tooltip: string;
-        class: string;
+        class: string | undefined;
         enabled: boolean;
         checked: boolean;
-        radio: boolean;
         run(event?: any): Promise<any>;
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/contextview/browser/contextView.ts#L38
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextview/browser/contextView.ts#L38
     export interface IContextMenuService {
         /**
          * Shows the native Monaco context menu in the editor.
@@ -201,23 +206,26 @@ declare module monaco.editor {
         showContextMenu(delegate: IContextMenuDelegate): void;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L615
     export interface IDecorationOptions {
         range: IRange;
         hoverMessage?: IMarkdownString | IMarkdownString[];
         renderOptions?: IDecorationInstanceRenderOptions;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L599
     export interface IThemeDecorationInstanceRenderOptions {
         before?: IContentDecorationRenderOptions;
         after?: IContentDecorationRenderOptions;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L607
     export interface IDecorationInstanceRenderOptions extends IThemeDecorationInstanceRenderOptions {
         light?: IThemeDecorationInstanceRenderOptions;
         dark?: IThemeDecorationInstanceRenderOptions;
     }
 
-    // https://github.com/TypeFox/vscode/blob/70b8db24a37fafc77247de7f7cb5bb0195120ed0/src/vs/editor/common/editorCommon.ts#L552
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L567
     export interface IContentDecorationRenderOptions {
         contentText?: string;
         contentIconPath?: UriComponents;
@@ -228,7 +236,7 @@ declare module monaco.editor {
         fontWeight?: string;
         textDecoration?: string;
         color?: string | ThemeColor;
-        opacity?: string;
+        opacity?: string; // does not exist in vs code
         backgroundColor?: string | ThemeColor;
 
         margin?: string;
@@ -236,6 +244,7 @@ declare module monaco.editor {
         height?: string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L587
     export interface IDecorationRenderOptions extends IThemeDecorationRenderOptions {
         isWholeLine?: boolean;
         rangeBehavior?: TrackedRangeStickiness;
@@ -245,7 +254,7 @@ declare module monaco.editor {
         dark?: IThemeDecorationRenderOptions;
     }
 
-    // https://github.com/TypeFox/vscode/blob/70b8db24a37fafc77247de7f7cb5bb0195120ed0/src/vs/editor/common/editorCommon.ts#L517
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/editorCommon.ts#L532
     export interface IThemeDecorationRenderOptions {
         backgroundColor?: string | ThemeColor;
 
@@ -277,19 +286,22 @@ declare module monaco.editor {
         before?: IContentDecorationRenderOptions;
         after?: IContentDecorationRenderOptions;
     }
-
 }
 
 declare module monaco.commands {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/commands/common/commands.ts#L55
     export const CommandsRegistry: {
         getCommands(): Map<string, { id: string, handler: (...args: any) => any }>;
     };
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/commands/common/commands.ts#L16
     export interface ICommandEvent {
         commandId: string;
+        args: any[];
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/commands/common/commands.ts#L21
     export interface ICommandService {
         readonly _onWillExecuteCommand: monaco.Emitter<ICommandEvent>;
         executeCommand<T>(commandId: string, ...args: any[]): Promise<T>;
@@ -300,23 +312,30 @@ declare module monaco.commands {
 
 declare module monaco.actions {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/actions/common/actions.ts#L22
     export interface ICommandAction {
         id: string;
         title: string
         category?: string;
-        iconClass?: string;
+        icon?: { dark?: monaco.Uri; light?: monaco.Uri; } | monaco.theme.ThemeIcon;
+        precondition?: monaco.contextkey.ContextKeyExpr;
+        toggled?: monaco.contextkey.ContextKeyExpr;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/actions/common/actions.ts#L35
     export interface IMenuItem {
         command: ICommandAction;
-        when?: any;
+        when?: monaco.contextkey.ContextKeyExpr;
         group?: 'navigation' | string;
+        order?: number;
+        alt?: ICommandAction;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/actions/common/actions.ts#L133
     export interface IMenuRegistry {
         /**
          * Retrieves all the registered menu items for the given menu.
-         * @param menuId - see https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/actions/common/actions.ts#L66
+         * @param menuId - see https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/actions/common/actions.ts#L67
          */
         getMenuItems(menuId: 7 /* EditorContext */): IMenuItem[];
     }
@@ -324,11 +343,12 @@ declare module monaco.actions {
     /**
      * The shared menu registry singleton.
      */
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/actions/common/actions.ts#L142
     export const MenuRegistry: IMenuRegistry;
-
 }
 
 declare module monaco.platform {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/platform.ts#L206
     export const enum OperatingSystem {
         Windows = 1,
         Macintosh = 2,
@@ -339,12 +359,12 @@ declare module monaco.platform {
 
 declare module monaco.keybindings {
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/keybinding/common/keybindingResolver.ts#L20
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/keybinding/common/keybindingResolver.ts#L20
     export class KeybindingResolver {
-        static contextMatchesRules(context: monaco.contextKeyService.IContext, rules: monaco.contextkey.ContextKeyExpr): boolean;
+        static contextMatchesRules(context: monaco.contextKeyService.IContext, rules: monaco.contextkey.ContextKeyExpr | null | undefined): boolean;
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/common/keyCodes.ts#L443
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keyCodes.ts#L443
     export class SimpleKeybinding {
         public readonly ctrlKey: boolean;
         public readonly shiftKey: boolean;
@@ -356,23 +376,22 @@ declare module monaco.keybindings {
         toChord(): ChordKeybinding;
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/common/keyCodes.ts#L503
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keyCodes.ts#L503
     export class ChordKeybinding {
         readonly parts: SimpleKeybinding[];
     }
 
-    export type Keybinding = SimpleKeybinding | ChordKeybinding;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keyCodes.ts#L540
+    export type Keybinding = ChordKeybinding;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/keybinding/common/keybindingsRegistry.ts#L12
     export interface IKeybindingItem {
         keybinding: Keybinding;
         command: string;
-        when?: ContextKeyExpr;
-    }
-
-    export interface ContextKeyExpr {
-        serialize(): string;
+        when?: monaco.contextkey.ContextKeyExpr;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/keybinding/common/keybindingsRegistry.ts#L69
     export interface IKeybindingsRegistry {
         /**
          * Returns with all the default, static keybindings.
@@ -380,10 +399,10 @@ declare module monaco.keybindings {
         getDefaultKeybindings(): IKeybindingItem[];
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/keybinding/common/keybindingsRegistry.ts#L75
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/keybinding/common/keybindingsRegistry.ts#L76
     export const KeybindingsRegistry: IKeybindingsRegistry;
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/common/keyCodes.ts#L542
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keyCodes.ts#L542
     export class ResolvedKeybindingPart {
         readonly ctrlKey: boolean;
         readonly shiftKey: boolean;
@@ -396,7 +415,7 @@ declare module monaco.keybindings {
         constructor(ctrlKey: boolean, shiftKey: boolean, altKey: boolean, metaKey: boolean, kbLabel: string | null, kbAriaLabel: string | null);
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/common/keyCodes.ts#L564
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keyCodes.ts#L564
     export abstract class ResolvedKeybinding {
         public abstract getLabel(): string | null;
         public abstract getAriaLabel(): string | null;
@@ -408,11 +427,12 @@ declare module monaco.keybindings {
         public abstract getDispatchParts(): (string | null)[];
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/keybinding/common/usLayoutResolvedKeybinding.ts#L13
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/keybinding/common/usLayoutResolvedKeybinding.ts#L13
     export class USLayoutResolvedKeybinding {
-        public static getDispatchStr(keybinding: SimpleKeybinding): string;
+        public static getDispatchStr(keybinding: SimpleKeybinding): string | null;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L17
     export interface Modifiers {
         readonly ctrlKey: boolean;
         readonly shiftKey: boolean;
@@ -420,30 +440,42 @@ declare module monaco.keybindings {
         readonly metaKey: boolean;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L24
     export interface KeyLabelProvider<T extends Modifiers> {
         (keybinding: T): string | null;
     }
 
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/common/keybindingLabels.ts#L28
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L28
     export interface ModifierLabelProvider {
         toLabel<T extends Modifiers>(OS: monaco.platform.OperatingSystem, parts: T[], keyLabelProvider: KeyLabelProvider<T>): string | null;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L61
     export const UILabelProvider: ModifierLabelProvider;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L88
     export const AriaLabelProvider: ModifierLabelProvider;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L116
     export const ElectronAcceleratorLabelProvider: ModifierLabelProvider;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/keybindingLabels.ts#L136
     export const UserSettingsLabelProvider: ModifierLabelProvider;
 
 }
 
 declare module monaco.services {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneLanguages.ts#L101
     export class TokenizationSupport2Adapter implements monaco.modes.ITokenizationSupport {
         constructor(standaloneThemeService: IStandaloneThemeService, languageIdentifier: LanguageIdentifier, actual: monaco.languages.TokensProvider)
         tokenize(line: string, state: monaco.languages.IState, offsetDelta: number): any;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/services/codeEditorService.ts#L13
     export const ICodeEditorService: any;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/configuration/common/configuration.ts#L16
     export const IConfigurationService: any;
 
     export interface Configuration {
@@ -451,19 +483,25 @@ declare module monaco.services {
     }
 
     export class ConfigurationChangeEvent {
-        // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/platform/configuration/common/configuration.ts#L30-L38
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/configuration/common/configuration.ts#L30-L37
         _source?: number;
+
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/configuration/common/configurationModels.ts#L620
         change(keys: string[]): ConfigurationChangeEvent;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/configuration/common/configuration.ts#L65
     export interface IConfigurationService {
         _onDidChangeConfiguration: monaco.Emitter<ConfigurationChangeEvent>;
         _configuration: Configuration;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/resourceConfiguration.ts#L39
     export interface ITextResourcePropertiesService {
+        getEOL(resource: monaco.Uri | undefined, language?: string): string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/services/codeEditorServiceImpl.ts#L17
     export abstract class CodeEditorServiceImpl implements monaco.editor.ICodeEditorService {
         constructor(themeService: IStandaloneThemeService);
         abstract getActiveCodeEditor(): monaco.editor.ICodeEditor | undefined;
@@ -474,6 +512,7 @@ declare module monaco.services {
         resolveDecorationOptions: monaco.editor.ICodeEditorService['resolveDecorationOptions'];
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/simpleServices.ts#L245
     export class StandaloneCommandService implements monaco.commands.ICommandService {
         constructor(instantiationService: monaco.instantiation.IInstantiationService);
         readonly _onWillExecuteCommand: monaco.Emitter<monaco.commands.ICommandEvent>;
@@ -481,66 +520,79 @@ declare module monaco.services {
         executeCommand(commandId: string, ...args: any[]): Promise<any>;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneServices.ts#L60
     export class LazyStaticService<T> {
         get(overrides?: monaco.editor.IEditorOverrideServices): T;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/common/standaloneThemeService.ts#L28
     export interface IStandaloneThemeService extends monaco.theme.IThemeService {
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneThemeServiceImpl.ts#L170
         readonly _knownThemes: Map<string, IStandaloneTheme>;
+
         getTheme(): IStandaloneTheme;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/common/standaloneThemeService.ts#L23
     export interface IStandaloneTheme {
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneThemeServiceImpl.ts#L30
         themeData: monaco.editor.IStandaloneThemeData
+
         tokenTheme: TokenTheme;
-        getColor(color: string): Color | undefined;
-    }
 
-    export interface TokenTheme {
-        match(languageId: string | undefined, scope: string): number;
-        getColorMap(): Color[];
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/themeService.ts#L91
+        getColor(color: string): monaco.color.Color | undefined;
     }
 
-    export interface Color {
-        rgba: RGBA;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes/supports/tokenization.ts#L188
+    export interface TokenTheme {
+        match(languageId: LanguageId, scope: string): number;
+        getColorMap(): monaco.color.Color[];
     }
 
-    export interface RGBA {
-        r: number;
-        g: number;
-        b: number;
-        a: number;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L27
+    export const enum LanguageId {
+        Null = 0,
+        PlainText = 1
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L35
     export class LanguageIdentifier {
+        public readonly id: LanguageId;
         readonly language: string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L58
     export interface IMode {
         getId(): string;
         getLanguageIdentifier(): LanguageIdentifier;
     }
 
-    // https://github.com/TypeFox/vscode/blob/70b8db24a37fafc77247de7f7cb5bb0195120ed0/src/vs/editor/common/services/modeService.ts#L30
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/modeService.ts#L30
     export interface IModeService {
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/modeServiceImpl.ts#L46
         private readonly _instantiatedModes: { [modeId: string]: IMode; };
         readonly onDidCreateMode: monaco.IEvent<IMode>;
         createByFilepathOrFirstLine(rsource: monaco.Uri | null, firstLine?: string): ILanguageSelection;
-        getLanguageIdentifier(modeId: string): LanguageIdentifier | null;
+        getLanguageIdentifier(modeId: string | LanguageId): LanguageIdentifier | null;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/services/modeService.ts#L25
     export interface ILanguageSelection {
         readonly languageIdentifier: LanguageIdentifier;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/instantiation/common/serviceCollection.ts#L9
     export interface ServiceCollection {
         set<T>(id: any, instanceOrDescriptor: T): T;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/markers/common/markers.ts#L12
     export interface IMarkerService {
-        read(filter?: { owner?: string; resource?: monaco.Uri; severities?: number, take?: number; }): editor.IMarkerData[];
+        read(filter?: { owner?: string; resource?: monaco.Uri; severities?: number, take?: number; }): editor.IMarker[];
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneServices.ts#L56
     export module StaticServices {
         export function init(overrides: monaco.editor.IEditorOverrideServices): [ServiceCollection, monaco.instantiation.IInstantiationService];
         export const standaloneThemeService: LazyStaticService<IStandaloneThemeService>;
@@ -554,140 +606,195 @@ declare module monaco.services {
 }
 
 declare module monaco.theme {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/themeService.ts#L82
     export interface ITheme { }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/themeService.ts#L124
     export interface IThemeService {
-        onThemeChange: monaco.IEvent<ITheme>;
+        readonly onThemeChange: monaco.IEvent<ITheme>;
     }
     export interface IThemable { }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/styler.ts#L166
     export function attachQuickOpenStyler(widget: IThemable, themeService: IThemeService): monaco.IDisposable;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/themeService.ts#L25
+    export interface ThemeIcon {
+        readonly id: string;
+    }
 }
 
 declare module monaco.color {
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/color.ts#L13
     export class RGBA {
+        readonly r: number;
+        readonly g: number;
+        readonly b: number;
+        readonly a: number;
+        
         constructor(r: number, g: number, b: number, a?: number);
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/color.ts#L48
     export class HSLA {
+        readonly h: number;
+        readonly s: number;
+        readonly l: number;
+        readonly a: number;
+
         constructor(h: number, s: number, l: number, a: number);
     }
+    
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/color.ts#L256
     export class Color {
+        readonly rgba: RGBA;
+
         constructor(arg: RGBA | HSLA);
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L20
     export interface ColorContribution {
         readonly id: string;
     }
-    export type ColorFunction = () => string | Color;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L29
+    export type ColorFunction = (theme: monaco.theme.ITheme) => Color | undefined;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L42
     export type ColorValue = string | Color | ColorFunction;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L33
     export interface ColorDefaults {
         light?: ColorValue;
         dark?: ColorValue;
         hc?: ColorValue;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L49
     export interface IColorRegistry {
         getColors(): ColorContribution[];
         registerColor(id: string, defaults: ColorDefaults | undefined, description: string): string;
         deregisterColor(id: string): void;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L173
     export function getColorRegistry(): IColorRegistry;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L434
     export function darken(colorValue: ColorValue, factor: number): ColorFunction;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L444
     export function lighten(colorValue: ColorValue, factor: number): ColorFunction;
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/theme/common/colorRegistry.ts#L454
     export function transparent(colorValue: ColorValue, factor: number): ColorFunction;
 }
 
 declare module monaco.referenceSearch {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L749
     export interface Location {
         uri: Uri,
         range: IRange
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/gotoSymbol/referencesModel.ts#L20
     export interface OneReference { }
 
-    export interface ReferencesModel {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/gotoSymbol/referencesModel.ts#L148
+    export interface ReferencesModel implements IDisposable {
         references: OneReference[]
     }
 
-    export interface RequestOptions {
-        getMetaTitle(model: ReferencesModel): string;
-    }
-
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/gotoSymbol/peek/referencesWidget.ts#L187
     export interface ReferenceWidget {
-        hide(): void;
         show(range: IRange): void;
+        hide(): void;
         focus(): void;
     }
 
-    export interface ReferencesController {
-        _widget: ReferenceWidget
-        _model: ReferencesModel | undefined
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/gotoSymbol/peek/referencesController.ts#L30
+    export interface ReferencesController extends IDisposable {
+        static readonly ID: string;
+        _widget?: ReferenceWidget;
+        _model?: ReferencesModel;
         _ignoreModelChangeEvent: boolean;
         _editorService: monaco.editor.ICodeEditorService;
         closeWidget(): void;
-        _gotoReference(ref: Location): void
-        toggleWidget(range: IRange, modelPromise: Promise<ReferencesModel> & { cancel: () => void }, options: RequestOptions): void;
+        _gotoReference(ref: Location): Promise<any>;
+        toggleWidget(range: IRange, modelPromise: Promise<ReferencesModel> & { cancel: () => void }, peekMode: boolean): void;
     }
-
 }
 
 declare module monaco.quickOpen {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/browser/ui/inputbox/inputBox.ts#L59
     export interface IMessage {
         content: string;
         formatContent?: boolean; // defaults to false
         type?: 1 /* INFO */ | 2  /* WARNING */ | 3 /* ERROR */;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/browser/ui/inputbox/inputBox.ts#L91
     export class InputBox {
         inputElement: HTMLInputElement;
         setPlaceHolder(placeHolder: string): void;
-        showMessage(message: IMessage): void;
+        showMessage(message: IMessage, force?: boolean): void;
         hideMessage(): void;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenWidget.ts#L96
     export class QuickOpenWidget implements IDisposable {
         inputBox?: InputBox;
-        constructor(container: HTMLElement, callbacks: IQuickOpenCallbacks, options: IQuickOpenOptions, usageLogger?: IQuickOpenUsageLogger);
+        constructor(container: HTMLElement, callbacks: IQuickOpenCallbacks, options: IQuickOpenOptions);
         dispose(): void;
         create(): HTMLElement;
-        setInput(input: IModel<any>, autoFocus: IAutoFocus, ariaLabel?: string): void;
+        setInput(input: IModel<any>, autoFocus?: IAutoFocus, ariaLabel?: string): void;
         layout(dimension: monaco.editor.IDimension): void;
         show(prefix: string, options?: IShowOptions): void;
+        show(input: IModel<any>, options?: IShowOptions): void;
         hide(reason?: HideReason): void;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenWidget.ts#L79
     export enum HideReason {
         ELEMENT_SELECTED,
         FOCUS_LOST,
         CANCELED
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenWidget.ts#L28
     export interface IQuickOpenCallbacks {
         onOk: () => void;
         onCancel: () => void;
-        onType: (lookFor?: string) => void;
+        onType: (lookFor: string) => void;
         onShow?: () => void;
         onHide?: (reason: HideReason) => void;
         onFocusLost?: () => boolean /* veto close */;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenWidget.ts#L37
     export interface IQuickOpenOptions /* extends IQuickOpenStyles */ {
         minItemsToShow?: number;
         maxItemsToShow?: number;
         inputPlaceHolder?: string;
         inputAriaLabel?: string;
-        // actionProvider?: IActionProvider;
+        actionProvider?: IActionProvider;
         keyboardSupport?: boolean;
     }
-    export interface IQuickOpenUsageLogger {
-        publicLog(eventName: string, data?: any): void;
-    }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenWidget.ts#L57
     export interface IShowOptions {
         quickNavigateConfiguration?: IQuickNavigateConfiguration;
         autoFocus?: IAutoFocus;
         inputSelection?: IRange;
+        value?: string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L8
     export interface IQuickNavigateConfiguration {
         keybindings: monaco.keybindings.ResolvedKeybinding[];
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L12
     export interface IAutoFocus {
 
         /**
@@ -718,20 +825,32 @@ declare module monaco.quickOpen {
          */
         autoFocusPrefixMatch?: string;
     }
-    // https://github.com/TypeFox/vscode/blob/monaco/0.18.0/src/vs/base/parts/quickopen/common/quickOpen.ts#L43-L48
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L43-L47
     export type Mode = 0 /* PREVIEW */ | 1 /* OPEN */ | 2 /* OPEN_IN_BACKGROUND */;
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L49
     export interface IEntryRunContext {
         event: any;
-        keymods: number[];
-        quickNavigateConfiguration: IQuickNavigateConfiguration;
+        keymods: IKeyMods;
+        quickNavigateConfiguration: IQuickNavigateConfiguration | undefined;
+    }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L55
+    export interface IKeyMods {
+        ctrlCmd: boolean;
+        alt: boolean;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L60
     export interface IDataSource<T> {
         getId(entry: T): string;
-        getLabel(entry: T): string;
+        getLabel(entry: T): string | null;
     }
     /**
      * See vs/base/parts/tree/browser/tree.ts - IRenderer
      */
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L68
     export interface IRenderer<T> {
         getHeight(entry: T): number;
         getTemplateId(entry: T): string;
@@ -739,15 +858,22 @@ declare module monaco.quickOpen {
         renderElement(entry: T, templateId: string, templateData: any, styles: any): void;
         disposeTemplate(templateId: string, templateData: any): void;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L78
     export interface IFilter<T> {
         isVisible(entry: T): boolean;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L82
     export interface IAccessiblityProvider<T> {
         getAriaLabel(entry: T): string;
     }
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L86
     export interface IRunner<T> {
         run(entry: T, mode: Mode, context: IEntryRunContext): boolean;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/common/quickOpen.ts#L90
     export interface IModel<T> {
         entries: T[];
         dataSource: IDataSource<T>;
@@ -757,21 +883,32 @@ declare module monaco.quickOpen {
         accessibilityProvider?: IAccessiblityProvider<T>;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenModel.ts#L29
     export interface IHighlight {
         start: number;
         end: number;
     }
-    export interface IIconLabelOptions {
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/browser/ui/iconLabel/iconLabel.ts#L20
+    export interface IIconLabelValueOptions {
         title?: string;
+        descriptionTitle?: string;
+        hideIcon?: boolean;
         extraClasses?: string[];
         italic?: boolean;
         matches?: monaco.filters.IMatch[];
+        labelEscapeNewLines?: boolean;
+        descriptionMatches?: monaco.filters.IMatch[];
+        readonly separator?: string;
+        readonly domId?: string;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenModel.ts#L55
     export class QuickOpenEntry {
         constructor(highlights?: IHighlight[]);
         getLabel(): string | undefined;
-        getLabelOptions(): IIconLabelOptions | undefined;
-        getAriaLabel(): string | undefined;
+        getLabelOptions(): IIconLabelValueOptions | undefined;
+        getAriaLabel(): string;
         getDetail(): string | undefined;
         getIcon(): string | undefined;
         getDescription(): string | undefined;
@@ -779,39 +916,32 @@ declare module monaco.quickOpen {
         getResource(): Uri | undefined;
         isHidden(): boolean;
         setHidden(hidden: boolean): void;
-        setHighlights(labelHighlights: IHighlight[], descriptionHighlights?: IHighlight[], detailHighlights?: IHighlight[]): void;
-        getHighlights(): [IHighlight[] /* Label */, IHighlight[] /* Description */, IHighlight[] /* Detail */];
+        setHighlights(labelHighlights?: IHighlight[], descriptionHighlights?: IHighlight[], detailHighlights?: IHighlight[]): void;
+        getHighlights(): [IHighlight[] | undefined /* Label */, IHighlight[] | undefined /* Description */, IHighlight[] | undefined /* Detail */];
         run(mode: Mode, context: IEntryRunContext): boolean;
     }
 
     export function compareEntries(elementA: QuickOpenEntry, elementB: QuickOpenEntry, lookFor: string): number;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenModel.ts#L197
     export class QuickOpenEntryGroup extends QuickOpenEntry {
         constructor(entry?: QuickOpenEntry, groupLabel?: string, withBorder?: boolean);
-        getGroupLabel(): string;
+        getGroupLabel(): string | undefined;
         setGroupLabel(groupLabel: string): void;
         showBorder(): boolean;
         setShowBorder(showBorder: boolean): void;
         getEntry(): QuickOpenEntry | undefined;
     }
 
-    export interface IAction extends IDisposable {
-        id: string;
-        label: string;
-        tooltip: string;
-        class: string | undefined;
-        enabled: boolean;
-        checked: boolean;
-        radio: boolean;
-        run(event?: any): PromiseLike<any>;
-    }
-
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/tree/browser/tree.ts#L571
     export interface IActionProvider {
         hasActions(element: any, item: any): boolean;
-        getActions(element: any, item: any): ReadonlyArray<IAction>;
+        getActions(element: any, item: any): ReadonlyArray<monaco.editor.IAction> | null;
     }
 
-    export class QuickOpenModel implements IModel<QuickOpenEntry>, IDataSource<QuickOpenEntry>, IFilter<QuickOpenEntry>, IRunner<QuickOpenEntry> {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/parts/quickopen/browser/quickOpenModel.ts#L489
+    export class QuickOpenModel implements IModel<QuickOpenEntry>, IDataSource<QuickOpenEntry>, IFilter<QuickOpenEntry>, IRunner<QuickOpenEntry>,
+        IAccessiblityProvider<QuickOpenEntry> {
         constructor(entries?: QuickOpenEntry[], actionProvider?: IActionProvider);
         addEntries(entries: QuickOpenEntry[]): void;
         entries: QuickOpenEntry[];
@@ -821,35 +951,43 @@ declare module monaco.quickOpen {
         filter?: IFilter<QuickOpenEntry>;
         accessibilityProvider?: IAccessiblityProvider<QuickOpenEntry>;
         getId(entry: QuickOpenEntry): string;
-        getLabel(entry: QuickOpenEntry): string;
+        getLabel(entry: QuickOpenEntry): string | null;
         isVisible(entry: QuickOpenEntry): boolean;
         run(entry: QuickOpenEntry, mode: Mode, context: IEntryRunContext): boolean;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/quickOpen/editorQuickOpen.ts#L19
     export interface IQuickOpenControllerOpts {
         readonly inputAriaLabel: string;
         getModel(lookFor: string): QuickOpenModel;
         getAutoFocus(lookFor: string): IAutoFocus;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/quickOpen/editorQuickOpen.ts#L25
     export interface QuickOpenController extends IDisposable {
-        getId(): string;
+        static readonly ID: string;
         run(opts: IQuickOpenControllerOpts): void;
+
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/quickOpen/editorQuickOpen.ts#L168-L169
         decorateLine(range: Range, editor: monaco.editor.ICodeEditor): void;
         clearDecorations(): void;
     }
-
 }
 
 declare module monaco.filters {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/filters.ts#L15
     export interface IMatch {
         start: number;
         end: number;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/filters.ts#L337
     export function matchesFuzzy(word: string, wordToMatchAgainst: string, enableSeparateSubstringMatching?: boolean): IMatch[] | undefined;
 }
 
 declare module monaco.editorExtensions {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/editorExtensions.ts#L205
     export interface EditorAction {
         id: string;
         label: string;
@@ -857,14 +995,18 @@ declare module monaco.editorExtensions {
     }
 
     export module EditorExtensionsRegistry {
+        // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/browser/editorExtensions.ts#L341
         export function getEditorActions(): EditorAction[];
     }
 }
 declare module monaco.modes {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L201
     export interface ITokenizationSupport {
         tokenize(line: string, state: monaco.languages.IState, offsetDelta: number): any;
     }
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L1613
     export interface TokenizationRegistry {
         get(language: string): ITokenizationSupport | null;
         getColorMap(): monaco.color.Color[] | null;
@@ -872,6 +1014,7 @@ declare module monaco.modes {
     }
     export const TokenizationRegistry: TokenizationRegistry;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L140
     export class TokenMetadata {
 
         public static getLanguageId(metadata: number): number;
@@ -887,11 +1030,13 @@ declare module monaco.modes {
         public static getInlineStyleFromMetadata(metadata: number, colorMap: string[]): string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/glob.ts#L18
     export interface IRelativePattern {
         base: string;
         pattern: string;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes/languageSelector.ts#L9
     export interface LanguageFilter {
         language?: string;
         scheme?: string;
@@ -903,32 +1048,40 @@ declare module monaco.modes {
         exclusive?: boolean;
     }
 
-    export type LanguageSelector = string | LanguageFilter | (string | LanguageFilter)[];
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes/languageSelector.ts#L20
+    export type LanguageSelector = string | LanguageFilter | Array<string | LanguageFilter>;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes/languageFeatureRegistry.ts#L29
     export interface LanguageFeatureRegistry<T> {
-        has(model: monaco.editor.IReadOnlyModel): boolean;
-        all(model: monaco.editor.IReadOnlyModel): T[];
+        has(model: monaco.editor.ITextModel): boolean;
+        all(model: monaco.editor.ITextModel): T[];
         register(selector: LanguageSelector, provider: T): IDisposable;
         readonly onDidChange: monaco.IEvent<number>;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L1525
     export const DocumentSymbolProviderRegistry: LanguageFeatureRegistry<monaco.languages.DocumentSymbolProvider>;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L1510
     export const CompletionProviderRegistry: LanguageFeatureRegistry<monaco.languages.CompletionItemProvider>;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/common/modes.ts#L1560
     export const CodeActionProviderRegistry: LanguageFeatureRegistry<monaco.languages.CodeActionProvider & { providedCodeActionKinds?: string[] }>;
 }
 
 declare module monaco.suggest {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/suggest/suggest.ts#L106
     export const enum SnippetSortOrder {
         Top, Inline, Bottom
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/suggest/suggest.ts#L28
     export interface CompletionItem {
         completion: monaco.languages.CompletionItem;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/suggest/suggest.ts#L110
     export class CompletionOptions {
 
         constructor(
@@ -939,6 +1092,7 @@ declare module monaco.suggest {
 
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/suggest/suggest.ts#L133
     export function provideSuggestionItems(
         model: monaco.editor.ITextModel,
         position: Position,
@@ -947,11 +1101,13 @@ declare module monaco.suggest {
         token?: monaco.CancellationToken
     ): Promise<CompletionItem[]>;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/suggest/suggest.ts#L127
     export function setSnippetSuggestSupport(support: monaco.languages.CompletionItemProvider): monaco.languages.CompletionItemProvider;
 
 }
 
 declare module monaco.snippetParser {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/contrib/snippet/snippetParser.ts#L583
     export class SnippetParser {
         parse(value: string): TextmateSnippet;
     }
@@ -961,20 +1117,35 @@ declare module monaco.snippetParser {
 
 declare module monaco.contextKeyService {
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L805
     export interface IContextKey<T> {
-        set(value: T | undefined): void;
+        set(value: T): void;
         reset(): void;
         get(): T | undefined;
     }
 
-    export interface IContextKeyService { }
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L829
+    export interface IContextKeyService {
+        // vs code has another object as argument https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L811
+        // which contains restcicted number of HTMLElement methods
+        createScoped(target?: HTMLElement): IContextKeyService;
+        getContext(target?: HTMLElement): IContext;
+        createKey<T>(key: string, defaultValue: T | undefined): IContextKey<T>;
+        contextMatchesRules(rules: monaco.contextkey.ContextKeyExpr | undefined): boolean;
+        onDidChangeContext: monaco.IEvent<IContextKeyChangeEvent>;
+    }
 
-    export interface IContext { }
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L801
+    export interface IContext {
+        getValue<T>(key: string): T | undefined;
+    }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L825
     export interface IContextKeyChangeEvent {
         affectsSome(keys: Set<string>): boolean;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/browser/contextKeyService.ts#L321
     export class ContextKeyService implements IContextKeyService {
         constructor(configurationService: monaco.services.IConfigurationService);
         createScoped(target?: HTMLElement): IContextKeyService;
@@ -983,17 +1154,20 @@ declare module monaco.contextKeyService {
         contextMatchesRules(rules: monaco.contextkey.ContextKeyExpr | undefined): boolean;
         onDidChangeContext: monaco.IEvent<IContextKeyChangeEvent>;
     }
-
 }
 
 declare module monaco.contextkey {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/platform/contextkey/common/contextkey.ts#L29
     export class ContextKeyExpr {
         keys(): string[];
         static deserialize(when: string): ContextKeyExpr;
+        serialize(): string;
     }
 }
 
 declare module monaco.mime {
+
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/mime.ts#L18
     export interface ITextMimeAssociation {
         readonly id: string;
         readonly mime: string;
@@ -1004,19 +1178,22 @@ declare module monaco.mime {
         readonly userConfigured?: boolean;
     }
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/mime.ts#L42
     export function registerTextMime(association: monaco.mime.ITextMimeAssociation, warnOnOverwrite: boolean): void;
 
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/mime.ts#L98
     export function clearTextMimes(onlyUserConfigured?: boolean): void;
 }
 
 declare module monaco.error {
+    // https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/base/common/errors.ts#L77
     export function onUnexpectedError(e: any): undefined;
 }
 
 /**
  * overloading languages register functions to accept LanguageSelector,
  * check that all register functions passing a selector to registries:
- * https://github.com/TypeFox/vscode/blob/70b8db24a37fafc77247de7f7cb5bb0195120ed0/src/vs/editor/standalone/browser/standaloneLanguages.ts#L335-L497
+ * https://github.com/theia-ide/vscode/blob/standalone/0.19.x/src/vs/editor/standalone/browser/standaloneLanguages.ts#L338-L495
  */
 declare module monaco.languages {
     export function registerReferenceProvider(selector: monaco.modes.LanguageSelector, provider: ReferenceProvider): IDisposable;