diff --git a/Jakefile b/Jakefile
index 16330305b6a..7c58800c79d 100644
--- a/Jakefile
+++ b/Jakefile
@@ -35,6 +35,7 @@ var compilerSources = [
     "types.ts",
     "scanner.ts",
     "parser.ts",
+    "utilities.ts",
     "binder.ts",
     "checker.ts",
     "emitter.ts",
@@ -47,26 +48,53 @@ var compilerSources = [
 
 var servicesSources = [
     "core.ts",
+    "sys.ts",
     "types.ts",
     "scanner.ts",
     "parser.ts",
+    "utilities.ts",
     "binder.ts",
     "checker.ts",
-    "emitter.ts"
+    "emitter.ts",
+    "diagnosticInformationMap.generated.ts"
 ].map(function (f) {
     return path.join(compilerDirectory, f);
 }).concat([
     "breakpoints.ts",
+    "navigationBar.ts",
+    "outliningElementsCollector.ts",
     "services.ts",
     "shims.ts",
     "signatureHelp.ts",
     "utilities.ts",
-    "navigationBar.ts",
-    "outliningElementsCollector.ts"
+    "formatting/formatting.ts",
+    "formatting/formattingContext.ts",
+    "formatting/formattingRequestKind.ts",
+    "formatting/formattingScanner.ts",
+    "formatting/references.ts",
+    "formatting/rule.ts",
+    "formatting/ruleAction.ts",
+    "formatting/ruleDescriptor.ts",
+    "formatting/ruleFlag.ts",
+    "formatting/ruleOperation.ts",
+    "formatting/ruleOperationContext.ts",
+    "formatting/rules.ts",
+    "formatting/rulesMap.ts",
+    "formatting/rulesProvider.ts",
+    "formatting/smartIndenter.ts",
+    "formatting/tokenRange.ts"
 ].map(function (f) {
     return path.join(servicesDirectory, f);
 }));
 
+var definitionsRoots = [
+    "compiler/types.d.ts",
+    "compiler/scanner.d.ts",
+    "compiler/parser.d.ts",
+    "compiler/checker.d.ts",
+    "services/services.d.ts",
+];
+
 var harnessSources = [
     "harness.ts",
     "sourceMapRecorder.ts",
@@ -148,25 +176,48 @@ var compilerFilename = "tsc.js";
     * @param prefixes: a list of files to prepend to the target file
     * @param useBuiltCompiler: true to use the built compiler, false to use the LKG
     * @param noOutFile: true to compile without using --out
+    * @param generateDeclarations: true to compile using --declaration
+    * @param outDir: true to compile using --outDir
+    * @param keepComments: false to compile using --removeComments
+    * @param callback: a function to execute after the compilation process ends
     */
-function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, callback) {
+function compileFile(outFile, sources, prereqs, prefixes, useBuiltCompiler, noOutFile, generateDeclarations, outDir, keepComments, noResolve, callback) {
     file(outFile, prereqs, function() {
         var dir = useBuiltCompiler ? builtLocalDirectory : LKGDirectory;
-        var options = "-removeComments --module commonjs -noImplicitAny ";
+        var options = "--module commonjs -noImplicitAny";
+
+        if (!keepComments) {
+            options += " -removeComments";
+        }
+
         if (generateDeclarations) {
-            options += "--declaration ";
+            options += " --declaration";
         }
 
         if (useDebugMode) {
-            options += "--preserveConstEnums ";
+            options += " --preserveConstEnums";
+        }
+
+        if (outDir) {
+            options += " --outDir " + outDir;
+        }
+
+        if (!noOutFile) {
+            options += " --out " + outFile;
+        }
+
+        if(noResolve) {
+            options += " --noResolve";
+        }
+
+        if (useDebugMode) {
+            options += " -sourcemap -mapRoot file:///" + path.resolve(path.dirname(outFile));
         }
 
         var cmd = host + " " + dir + compilerFilename + " " + options + " ";
-        cmd = cmd + sources.join(" ") + (!noOutFile ? " -out " + outFile : "");
-        if (useDebugMode) {
-            cmd = cmd + " -sourcemap -mapRoot file:///" + path.resolve(path.dirname(outFile));
-        }
+        cmd = cmd + sources.join(" ");
         console.log(cmd + "\n");
+
         var ex = jake.createExec([cmd]);
         // Add listeners for output and error
         ex.addListener("stdout", function(output) {
@@ -259,24 +310,38 @@ var tscFile = path.join(builtLocalDirectory, compilerFilename);
 compileFile(tscFile, compilerSources, [builtLocalDirectory, copyright].concat(compilerSources), [copyright], /*useBuiltCompiler:*/ false);
 
 var servicesFile = path.join(builtLocalDirectory, "typescriptServices.js");
-var servicesDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts");
+compileFile(servicesFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources), [copyright], /*useBuiltCompiler*/ true);
 
-compileFile(servicesFile,
-            servicesSources,
-            [builtLocalDirectory, copyright].concat(servicesSources),
-            [copyright],
+var nodeDefinitionsFile = path.join(builtLocalDirectory, "typescript.d.ts");
+var standaloneDefinitionsFile = path.join(builtLocalDirectory, "typescriptServices.d.ts");
+var tempDirPath = path.join(builtLocalDirectory, "temptempdir");
+compileFile(nodeDefinitionsFile, servicesSources,[builtLocalDirectory, copyright].concat(servicesSources),
+            /*prefixes*/ undefined,
             /*useBuiltCompiler*/ true,
-            /*noOutFile*/ false,
+            /*noOutFile*/ true,
             /*generateDeclarations*/ true,
-            /*callback*/ fixDeclarationFile);
+            /*outDir*/ tempDirPath,
+            /*keepComments*/ true,
+            /*noResolve*/ true,
+            /*callback*/ function () {
+                concatenateFiles(standaloneDefinitionsFile, definitionsRoots.map(function (f) {
+                    return path.join(tempDirPath, f);
+                }));
+                prependFile(copyright, standaloneDefinitionsFile);
 
-function fixDeclarationFile() {
-    fs.appendFileSync(servicesDefinitionsFile, os.EOL + "export = ts;")
-}
+                // Create the node definition file by replacing 'ts' module with '"typescript"' as a module.
+                jake.cpR(standaloneDefinitionsFile, nodeDefinitionsFile, {silent: true});
+                var definitionFileContents = fs.readFileSync(nodeDefinitionsFile).toString();
+                definitionFileContents = definitionFileContents.replace(/declare module ts/g, 'declare module "typescript"');
+                fs.writeFileSync(nodeDefinitionsFile, definitionFileContents);
+
+                // Delete the temp dir
+                jake.rmRf(tempDirPath, {silent: true});
+           });
 
 // Local target to build the compiler and services
 desc("Builds the full compiler and services");
-task("local", ["generate-diagnostics", "lib", tscFile, servicesFile]);
+task("local", ["generate-diagnostics", "lib", tscFile, servicesFile, nodeDefinitionsFile]);
 
 // Local target to build the compiler and services
 desc("Sets release mode flag");
@@ -327,7 +392,7 @@ task("generate-spec", [specMd])
 // Makes a new LKG. This target does not build anything, but errors if not all the outputs are present in the built/local directory
 desc("Makes a new LKG out of the built js files");
 task("LKG", ["clean", "release", "local"].concat(libraryTargets), function() {
-    var expectedFiles = [tscFile, servicesFile, servicesDefinitionsFile].concat(libraryTargets);
+    var expectedFiles = [tscFile, servicesFile, nodeDefinitionsFile, standaloneDefinitionsFile].concat(libraryTargets);
     var missingFiles = expectedFiles.filter(function (f) {
         return !fs.existsSync(f);
     });
diff --git a/package.json b/package.json
index f6391394c6a..a52067a3d08 100644
--- a/package.json
+++ b/package.json
@@ -25,7 +25,7 @@
 		"url" : "https://github.com/Microsoft/TypeScript.git"  
 	},
 	"preferGlobal" : true,
-	"main" : "./bin/tsc.js",
+	"main" : "./bin/typescriptServices.js",
 	"bin" : { 
 		"tsc" : "./bin/tsc" 
 	},
diff --git a/src/compiler/checker.ts b/src/compiler/checker.ts
index 6d913f7360c..889b387d4f4 100644
--- a/src/compiler/checker.ts
+++ b/src/compiler/checker.ts
@@ -4,57 +4,12 @@
 /// <reference path="parser.ts"/>
 /// <reference path="binder.ts"/>
 /// <reference path="emitter.ts"/>
+/// <reference path="utilities.ts"/>
 
 module ts {
     var nextSymbolId = 1;
     var nextNodeId = 1;
-    var nextMergeId = 1;
-
-    export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration {
-        var declarations = symbol.declarations;
-        for (var i = 0; i < declarations.length; i++) {
-            var declaration = declarations[i];
-            if (declaration.kind === kind) {
-                return declaration;
-            }
-        }
-
-        return undefined;
-    }
-
-    export interface StringSymbolWriter extends SymbolWriter {
-        string(): string;
-    }
-
-    // Pool writers to avoid needing to allocate them for every symbol we write.
-    var stringWriters: StringSymbolWriter[] = [];
-    export function getSingleLineStringWriter(): StringSymbolWriter {
-        if (stringWriters.length == 0) {
-            var str = "";
-
-            var writeText: (text: string) => void = text => str += text;
-            return {
-                string: () => str,
-                writeKeyword: writeText,
-                writeOperator: writeText,
-                writePunctuation: writeText,
-                writeSpace: writeText,
-                writeStringLiteral: writeText,
-                writeParameter: writeText,
-                writeSymbol: writeText,
-
-                // Completely ignore indentation for string writers.  And map newlines to
-                // a single space.
-                writeLine: () => str += " ",
-                increaseIndent: () => { },
-                decreaseIndent: () => { },
-                clear: () => str = "",
-                trackSymbol: () => { }
-            };
-        }
-
-        return stringWriters.pop();
-    }
+    var nextMergeId = 1;    
 
     /// fullTypeCheck denotes if this instance of the typechecker will be used to get semantic diagnostics.
     /// If fullTypeCheck === true,  then the typechecker should do every possible check to produce all errors
@@ -1019,11 +974,6 @@ module ts {
             };
         }
 
-        function releaseStringWriter(writer: StringSymbolWriter) {
-            writer.clear()
-            stringWriters.push(writer);
-        }
-
         function writeKeyword(writer: SymbolWriter, kind: SyntaxKind) {
             writer.writeKeyword(tokenToString(kind));
         }
@@ -4445,8 +4395,8 @@ module ts {
         // Get the narrowed type of a given symbol at a given location
         function getNarrowedTypeOfSymbol(symbol: Symbol, node: Node) {
             var type = getTypeOfSymbol(symbol);
-            // Only narrow when symbol is variable of a structured type
-            if (node && (symbol.flags & SymbolFlags.Variable && type.flags & TypeFlags.Structured)) {
+            // Only narrow when symbol is variable of an object, union, or type parameter type
+            if (node && symbol.flags & SymbolFlags.Variable && type.flags & (TypeFlags.ObjectType | TypeFlags.Union | TypeFlags.TypeParameter)) {
                 loop: while (node.parent) {
                     var child = node;
                     node = node.parent;
@@ -5385,7 +5335,7 @@ module ts {
                 }
 
                 // Fall back to any.
-                if (compilerOptions.noImplicitAny && objectType !== anyType) {
+                if (compilerOptions.noImplicitAny && !compilerOptions.suppressImplicitAnyIndexErrors && objectType !== anyType) {
                     error(node, Diagnostics.Index_signature_of_object_type_implicitly_has_an_any_type);
                 }
 
@@ -6400,12 +6350,12 @@ module ts {
             return numberType;
         }
 
-        // Return true if type is any, an object type, a type parameter, or a union type composed of only those kinds of types
+        // Return true if type an object type, a type parameter, or a union type composed of only those kinds of types
         function isStructuredType(type: Type): boolean {
             if (type.flags & TypeFlags.Union) {
                 return !forEach((<UnionType>type).types, t => !isStructuredType(t));
             }
-            return (type.flags & TypeFlags.Structured) !== 0;
+            return (type.flags & (TypeFlags.ObjectType | TypeFlags.TypeParameter)) !== 0;
         }
 
         function isConstEnumObjectType(type: Type) : boolean {
@@ -6422,11 +6372,11 @@ module ts {
             // and the right operand to be of type Any or a subtype of the 'Function' interface type. 
             // The result is always of the Boolean primitive type.
             // NOTE: do not raise error if leftType is unknown as related error was already reported
-            if (leftType !== unknownType && !isStructuredType(leftType)) {
+            if (!(leftType.flags & TypeFlags.Any || isStructuredType(leftType))) {
                 error(node.left, Diagnostics.The_left_hand_side_of_an_instanceof_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             // NOTE: do not raise error if right is unknown as related error was already reported
-            if (rightType !== unknownType && rightType !== anyType && !isTypeSubtypeOf(rightType, globalFunctionType)) {
+            if (!(rightType.flags & TypeFlags.Any || isTypeSubtypeOf(rightType, globalFunctionType))) {
                 error(node.right, Diagnostics.The_right_hand_side_of_an_instanceof_expression_must_be_of_type_any_or_of_a_type_assignable_to_the_Function_interface_type);
             }
             return booleanType;
@@ -6440,7 +6390,7 @@ module ts {
             if (leftType !== anyType && leftType !== stringType && leftType !== numberType) {
                 error(node.left, Diagnostics.The_left_hand_side_of_an_in_expression_must_be_of_types_any_string_or_number);
             }
-            if (!isStructuredType(rightType)) {
+            if (!(rightType.flags & TypeFlags.Any || isStructuredType(rightType))) {
                 error(node.right, Diagnostics.The_right_hand_side_of_an_in_expression_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
             return booleanType;
@@ -7796,7 +7746,7 @@ module ts {
             var exprType = checkExpression(node.expression);
             // unknownType is returned i.e. if node.expression is identifier whose name cannot be resolved
             // in this case error about missing name is already reported - do not report extra one
-            if (!isStructuredType(exprType) && exprType !== unknownType) {
+            if (!(exprType.flags & TypeFlags.Any || isStructuredType(exprType))) {
                 error(node.expression, Diagnostics.The_right_hand_side_of_a_for_in_statement_must_be_of_type_any_an_object_type_or_a_type_parameter);
             }
 
diff --git a/src/compiler/commandLineParser.ts b/src/compiler/commandLineParser.ts
index 3fabf6c8588..ae4c751869c 100644
--- a/src/compiler/commandLineParser.ts
+++ b/src/compiler/commandLineParser.ts
@@ -88,6 +88,11 @@ module ts {
             description: Diagnostics.Redirect_output_structure_to_the_directory,
             paramType: Diagnostics.DIRECTORY,
         },
+        {
+            name: "preserveConstEnums",
+            type: "boolean",
+            description: Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
+        },
         {
             name: "removeComments",
             type: "boolean",
@@ -104,6 +109,11 @@ module ts {
             description: Diagnostics.Specifies_the_location_where_debugger_should_locate_TypeScript_files_instead_of_source_locations,
             paramType: Diagnostics.LOCATION,
         },
+        {
+            name: "suppressImplicitAnyIndexErrors",
+            type: "boolean",
+            description: Diagnostics.Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures,
+        },
         {
             name: "target",
             shortName: "t",
@@ -124,13 +134,8 @@ module ts {
             type: "boolean",
             description: Diagnostics.Watch_input_files,
         },
-        {
-            name: "preserveConstEnums",
-            type: "boolean",
-            description: Diagnostics.Do_not_erase_const_enum_declarations_in_generated_code
-        }
     ];
-
+    
     var shortOptionNames: Map<string> = {};
     var optionNameMap: Map<CommandLineOption> = {};
 
diff --git a/src/compiler/core.ts b/src/compiler/core.ts
index 8dfc0d59ea9..e61602c1c45 100644
--- a/src/compiler/core.ts
+++ b/src/compiler/core.ts
@@ -15,10 +15,6 @@ module ts {
         True  = -1
     }
 
-    export interface Map<T> {
-        [index: string]: T;
-    }
-
     export const enum Comparison {
         LessThan    = -1,
         EqualTo     = 0,
diff --git a/src/compiler/diagnosticInformationMap.generated.ts b/src/compiler/diagnosticInformationMap.generated.ts
index 7377c42b238..6ce7579588e 100644
--- a/src/compiler/diagnosticInformationMap.generated.ts
+++ b/src/compiler/diagnosticInformationMap.generated.ts
@@ -411,6 +411,7 @@ module ts {
         Warn_on_expressions_and_declarations_with_an_implied_any_type: { code: 6052, category: DiagnosticCategory.Message, key: "Warn on expressions and declarations with an implied 'any' type." },
         File_0_not_found: { code: 6053, category: DiagnosticCategory.Error, key: "File '{0}' not found." },
         File_0_must_have_extension_ts_or_d_ts: { code: 6054, category: DiagnosticCategory.Error, key: "File '{0}' must have extension '.ts' or '.d.ts'." },
+        Suppress_noImplicitAny_errors_for_indexing_objects_lacking_index_signatures: { code: 6055, category: DiagnosticCategory.Message, key: "Suppress noImplicitAny errors for indexing objects lacking index signatures." },
         Variable_0_implicitly_has_an_1_type: { code: 7005, category: DiagnosticCategory.Error, key: "Variable '{0}' implicitly has an '{1}' type." },
         Parameter_0_implicitly_has_an_1_type: { code: 7006, category: DiagnosticCategory.Error, key: "Parameter '{0}' implicitly has an '{1}' type." },
         Member_0_implicitly_has_an_1_type: { code: 7008, category: DiagnosticCategory.Error, key: "Member '{0}' implicitly has an '{1}' type." },
diff --git a/src/compiler/diagnosticMessages.json b/src/compiler/diagnosticMessages.json
index f0dba54e1a1..3e5ac7ae1d6 100644
--- a/src/compiler/diagnosticMessages.json
+++ b/src/compiler/diagnosticMessages.json
@@ -1643,6 +1643,10 @@
         "category": "Error",
         "code": 6054
     },
+    "Suppress noImplicitAny errors for indexing objects lacking index signatures.": {
+        "category": "Message",
+        "code": 6055
+    },
 
     "Variable '{0}' implicitly has an '{1}' type.": {
         "category": "Error",
diff --git a/src/compiler/parser.ts b/src/compiler/parser.ts
index deb2eb17fc8..2c8a09faaa1 100644
--- a/src/compiler/parser.ts
+++ b/src/compiler/parser.ts
@@ -1,41 +1,11 @@
 /// <reference path="types.ts"/>
 /// <reference path="core.ts"/>
 /// <reference path="scanner.ts"/>
+/// <reference path="utilities.ts"/>
 
 module ts {
     var nodeConstructors = new Array<new () => Node>(SyntaxKind.Count);
 
-    export function getFullWidth(node: Node) {
-        return node.end - node.pos;
-    }
-
-    function hasFlag(val: number, flag: number): boolean {
-        return (val & flag) !== 0;
-    }
-
-    // Returns true if this node contains a parse error anywhere underneath it.
-    export function containsParseError(node: Node): boolean {
-        if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasPropagatedChildContainsErrorFlag)) {
-            // A node is considered to contain a parse error if:
-            //  a) the parser explicitly marked that it had an error
-            //  b) any of it's children reported that it had an error.
-            var val = hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError) ||
-                forEachChild(node, containsParseError);
-
-            // If so, mark ourselves accordingly. 
-            if (val) {
-                node.parserContextFlags |= ParserContextFlags.ContainsError;
-            }
-
-            // Also mark that we've propogated the child information to this node.  This way we can
-            // always consult the bit directly on this node without needing to check its children
-            // again.
-            node.parserContextFlags |= ParserContextFlags.HasPropagatedChildContainsErrorFlag;
-        }
-
-        return hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError);
-    }
-
     export function getNodeConstructor(kind: SyntaxKind): new () => Node {
         return nodeConstructors[kind] || (nodeConstructors[kind] = objectAllocator.getNodeConstructor(kind));
     }
@@ -54,181 +24,6 @@ module ts {
         amdModuleName: string;
     }
 
-    export function getSourceFileOfNode(node: Node): SourceFile {
-        while (node && node.kind !== SyntaxKind.SourceFile) node = node.parent;
-        return <SourceFile>node;
-    }
-
-    // This is a useful function for debugging purposes.
-    export function nodePosToString(node: Node): string {
-        var file = getSourceFileOfNode(node);
-        var loc = file.getLineAndCharacterFromPosition(node.pos);
-        return file.filename + "(" + loc.line + "," + loc.character + ")";
-    }
-
-    export function getStartPosOfNode(node: Node): number {
-        return node.pos;
-    }
-
-    export function isMissingNode(node: Node) {
-        return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken;
-    }
-
-    export function getTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
-        // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*
-        // want to skip trivia because this will launch us forward to the next token.
-        if (isMissingNode(node)) {
-            return node.pos;
-        }
-
-        return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
-    }
-
-    export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string {
-        if (isMissingNode(node)) {
-            return "";
-        }
-
-        var text = sourceFile.text;
-        return text.substring(skipTrivia(text, node.pos), node.end);
-    }
-
-    export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string {
-        if (isMissingNode(node)) {
-            return "";
-        }
-
-        return sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
-    }
-
-    export function getTextOfNode(node: Node): string {
-        return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node);
-    }
-
-    // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__'
-    export function escapeIdentifier(identifier: string): string {
-        return identifier.length >= 2 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ ? "_" + identifier : identifier;
-    }
-
-    // Remove extra underscore from escaped identifier
-    export function unescapeIdentifier(identifier: string): string {
-        return identifier.length >= 3 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ && identifier.charCodeAt(2) === CharacterCodes._ ? identifier.substr(1) : identifier;
-    }
-
-    // Return display name of an identifier
-    // Computed property names will just be emitted as "[<expr>]", where <expr> is the source
-    // text of the expression in the computed property.
-    export function declarationNameToString(name: DeclarationName) {
-        return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
-    }
-
-    export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic {
-        node = getErrorSpanForNode(node);
-        var file = getSourceFileOfNode(node);
-
-        var start = getFullWidth(node) === 0 ? node.pos : skipTrivia(file.text, node.pos);
-        var length = node.end - start;
-
-        return createFileDiagnostic(file, start, length, message, arg0, arg1, arg2);
-    }
-
-    export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, newLine: string): Diagnostic {
-        node = getErrorSpanForNode(node);
-        var file = getSourceFileOfNode(node);
-        var start = skipTrivia(file.text, node.pos);
-        var length = node.end - start;
-        return flattenDiagnosticChain(file, start, length, messageChain, newLine);
-    }
-
-    export function getErrorSpanForNode(node: Node): Node {
-        var errorSpan: Node;
-        switch (node.kind) {
-            // This list is a work in progress. Add missing node kinds to improve their error
-            // spans.
-            case SyntaxKind.VariableDeclaration:
-            case SyntaxKind.ClassDeclaration:
-            case SyntaxKind.InterfaceDeclaration:
-            case SyntaxKind.ModuleDeclaration:
-            case SyntaxKind.EnumDeclaration:
-            case SyntaxKind.EnumMember:
-                errorSpan = (<Declaration>node).name;
-                break;
-        }
-
-        // We now have the ideal error span, but it may be a node that is optional and absent
-        // (e.g. the name of a function expression), in which case errorSpan will be undefined.
-        // Alternatively, it might be required and missing (e.g. the name of a module), in which
-        // case its pos will equal its end (length 0). In either of these cases, we should fall
-        // back to the original node that the error was issued on.
-        return errorSpan && errorSpan.pos < errorSpan.end ? errorSpan : node;
-    }
-
-    export function isExternalModule(file: SourceFile): boolean {
-        return file.externalModuleIndicator !== undefined;
-    }
-
-    export function isDeclarationFile(file: SourceFile): boolean {
-        return (file.flags & NodeFlags.DeclarationFile) !== 0;
-    }
-
-    export function isConstEnumDeclaration(node: Node): boolean {
-        return node.kind === SyntaxKind.EnumDeclaration && isConst(node);
-    }
-
-    export function isConst(node: Node): boolean {
-        return !!(node.flags & NodeFlags.Const);
-    }
-
-    export function isLet(node: Node): boolean {
-        return !!(node.flags & NodeFlags.Let);
-    }
-
-    export function isPrologueDirective(node: Node): boolean {
-        return node.kind === SyntaxKind.ExpressionStatement && (<ExpressionStatement>node).expression.kind === SyntaxKind.StringLiteral;
-    }
-
-    function isEvalOrArgumentsIdentifier(node: Node): boolean {
-        return node.kind === SyntaxKind.Identifier &&
-            (<Identifier>node).text &&
-            ((<Identifier>node).text === "eval" || (<Identifier>node).text === "arguments");
-    }
-
-    /// Should be called only on prologue directives (isPrologueDirective(node) should be true)
-    function isUseStrictPrologueDirective(node: Node): boolean {
-        Debug.assert(isPrologueDirective(node));
-        return (<Identifier>(<ExpressionStatement>node).expression).text === "use strict";
-    }
-
-    export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) {
-        sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node);
-
-        // If parameter/type parameter, the prev token trailing comments are part of this node too
-        if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) {
-            // e.g.   (/** blah */ a, /** blah */ b);
-            return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos),
-                // e.g.:     (
-                //            /** blah */ a,
-                //            /** blah */ b);
-                getLeadingCommentRanges(sourceFileOfNode.text, node.pos));
-        }
-        else {
-            return getLeadingCommentRanges(sourceFileOfNode.text, node.pos);
-        }
-    }
-
-    export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) {
-        return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment);
-
-        function isJsDocComment(comment: CommentRange) {
-            // True if the comment starts with '/**' but not if it is '/**/'
-            return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
-                sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&
-                sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash;
-        }
-    }
-
-    export var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/
-
     // Invokes a callback for each child of the given node. The 'cbNode' callback is invoked for all child nodes
     // stored in properties. If a 'cbNodes' callback is specified, it is invoked for embedded arrays; otherwise,
     // embedded arrays are flattened and the 'cbNode' callback is invoked for each element. If a callback returns
@@ -473,400 +268,78 @@ module ts {
         }
     }
 
-    // Warning: This has the same semantics as the forEach family of functions,
-    //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
-    export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
+    // TODO (drosen, mhegazy): Move to a more appropriate file.
+    export function createCompilerHost(options: CompilerOptions): CompilerHost {
+        var currentDirectory: string;
+        var existingDirectories: Map<boolean> = {};
 
-        return traverse(body);
-
-        function traverse(node: Node): T {
-            switch (node.kind) {
-                case SyntaxKind.ReturnStatement:
-                    return visitor(<ReturnStatement>node);
-                case SyntaxKind.Block:
-                case SyntaxKind.IfStatement:
-                case SyntaxKind.DoStatement:
-                case SyntaxKind.WhileStatement:
-                case SyntaxKind.ForStatement:
-                case SyntaxKind.ForInStatement:
-                case SyntaxKind.WithStatement:
-                case SyntaxKind.SwitchStatement:
-                case SyntaxKind.CaseClause:
-                case SyntaxKind.DefaultClause:
-                case SyntaxKind.LabeledStatement:
-                case SyntaxKind.TryStatement:
-                case SyntaxKind.TryBlock:
-                case SyntaxKind.CatchClause:
-                case SyntaxKind.FinallyBlock:
-                    return forEachChild(node, traverse);
-            }
-        }
-    }
-
-    export function isAnyFunction(node: Node): boolean {
-        if (node) {
-            switch (node.kind) {
-                case SyntaxKind.FunctionExpression:
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.ArrowFunction:
-                case SyntaxKind.Method:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                case SyntaxKind.Constructor:
-                    return true;
-            }
-        }
-
-        return false;
-    }
-
-    export function isFunctionBlock(node: Node) {
-        return node !== undefined && node.kind === SyntaxKind.Block && isAnyFunction(node.parent);
-    }
-
-    export function isObjectLiteralMethod(node: Node) {
-        return node !== undefined && node.kind === SyntaxKind.Method && node.parent.kind === SyntaxKind.ObjectLiteralExpression;
-    }
-
-    export function getContainingFunction(node: Node): FunctionLikeDeclaration {
-        while (true) {
-            node = node.parent;
-            if (!node || isAnyFunction(node)) {
-                return <FunctionLikeDeclaration>node;
-            }
-        }
-    }
-
-    export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node {
-        while (true) {
-            node = node.parent;
-            if (!node) {
-                return undefined;
-            }
-            switch (node.kind) {
-                case SyntaxKind.ArrowFunction:
-                    if (!includeArrowFunctions) {
-                        continue;
-                    }
-                // Fall through
-                case SyntaxKind.FunctionDeclaration:
-                case SyntaxKind.FunctionExpression:
-                case SyntaxKind.ModuleDeclaration:
-                case SyntaxKind.Property:
-                case SyntaxKind.Method:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                case SyntaxKind.EnumDeclaration:
-                case SyntaxKind.SourceFile:
-                    return node;
-            }
-        }
-    }
-
-    export function getSuperContainer(node: Node): Node {
-        while (true) {
-            node = node.parent;
-            if (!node) {
-                return undefined;
-            }
-            switch (node.kind) {
-                case SyntaxKind.Property:
-                case SyntaxKind.Method:
-                case SyntaxKind.Constructor:
-                case SyntaxKind.GetAccessor:
-                case SyntaxKind.SetAccessor:
-                    return node;
-            }
-        }
-    }
-
-    export function getInvokedExpression(node: CallLikeExpression): Expression {
-        if (node.kind === SyntaxKind.TaggedTemplateExpression) {
-            return (<TaggedTemplateExpression>node).tag;
+        function getCanonicalFileName(fileName: string): string {
+            // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
+            // otherwise use toLowerCase as a canonical form.
+            return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
         }
         
-        // Will either be a CallExpression or NewExpression.
-        return (<CallExpression>node).expression;
-    }
+        // returned by CScript sys environment
+        var unsupportedFileEncodingErrorCode = -2147024809;
 
-    export function isExpression(node: Node): boolean {
-        switch (node.kind) {
-            case SyntaxKind.ThisKeyword:
-            case SyntaxKind.SuperKeyword:
-            case SyntaxKind.NullKeyword:
-            case SyntaxKind.TrueKeyword:
-            case SyntaxKind.FalseKeyword:
-            case SyntaxKind.RegularExpressionLiteral:
-            case SyntaxKind.ArrayLiteralExpression:
-            case SyntaxKind.ObjectLiteralExpression:
-            case SyntaxKind.PropertyAccessExpression:
-            case SyntaxKind.ElementAccessExpression:
-            case SyntaxKind.CallExpression:
-            case SyntaxKind.NewExpression:
-            case SyntaxKind.TaggedTemplateExpression:
-            case SyntaxKind.TypeAssertionExpression:
-            case SyntaxKind.ParenthesizedExpression:
-            case SyntaxKind.FunctionExpression:
-            case SyntaxKind.ArrowFunction:
-            case SyntaxKind.VoidExpression:
-            case SyntaxKind.DeleteExpression:
-            case SyntaxKind.TypeOfExpression:
-            case SyntaxKind.PrefixUnaryExpression:
-            case SyntaxKind.PostfixUnaryExpression:
-            case SyntaxKind.BinaryExpression:
-            case SyntaxKind.ConditionalExpression:
-            case SyntaxKind.TemplateExpression:
-            case SyntaxKind.NoSubstitutionTemplateLiteral:
-            case SyntaxKind.OmittedExpression:
-                return true;
-            case SyntaxKind.QualifiedName:
-                while (node.parent.kind === SyntaxKind.QualifiedName) {
-                    node = node.parent;
+        function getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
+            try {
+                var text = sys.readFile(filename, options.charset);
+            }
+            catch (e) {
+                if (onError) {
+                    onError(e.number === unsupportedFileEncodingErrorCode ?
+                        createCompilerDiagnostic(Diagnostics.Unsupported_file_encoding).messageText :
+                        e.message);
                 }
+                text = "";
+            }
+            return text !== undefined ? createSourceFile(filename, text, languageVersion, /*version:*/ "0") : undefined;
+        }
 
-                return node.parent.kind === SyntaxKind.TypeQuery;
-            case SyntaxKind.Identifier:
-                if (node.parent.kind === SyntaxKind.TypeQuery) {
+        function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
+
+            function directoryExists(directoryPath: string): boolean {
+                if (hasProperty(existingDirectories, directoryPath)) {
                     return true;
                 }
-            // fall through
-            case SyntaxKind.NumericLiteral:
-            case SyntaxKind.StringLiteral:
-                var parent = node.parent;
-                switch (parent.kind) {
-                    case SyntaxKind.VariableDeclaration:
-                    case SyntaxKind.Parameter:
-                    case SyntaxKind.Property:
-                    case SyntaxKind.EnumMember:
-                    case SyntaxKind.PropertyAssignment:
-                        return (<VariableDeclaration>parent).initializer === node;
-                    case SyntaxKind.ExpressionStatement:
-                    case SyntaxKind.IfStatement:
-                    case SyntaxKind.DoStatement:
-                    case SyntaxKind.WhileStatement:
-                    case SyntaxKind.ReturnStatement:
-                    case SyntaxKind.WithStatement:
-                    case SyntaxKind.SwitchStatement:
-                    case SyntaxKind.CaseClause:
-                    case SyntaxKind.ThrowStatement:
-                    case SyntaxKind.SwitchStatement:
-                        return (<ExpressionStatement>parent).expression === node;
-                    case SyntaxKind.ForStatement:
-                        return (<ForStatement>parent).initializer === node ||
-                            (<ForStatement>parent).condition === node ||
-                            (<ForStatement>parent).iterator === node;
-                    case SyntaxKind.ForInStatement:
-                        return (<ForInStatement>parent).variable === node ||
-                            (<ForInStatement>parent).expression === node;
-                    case SyntaxKind.TypeAssertionExpression:
-                        return node === (<TypeAssertion>parent).expression;
-                    case SyntaxKind.TemplateSpan:
-                        return node === (<TemplateSpan>parent).expression;
-                    default:
-                        if (isExpression(parent)) {
-                            return true;
-                        }
+                if (sys.directoryExists(directoryPath)) {
+                    existingDirectories[directoryPath] = true;
+                    return true;
                 }
-        }
-        return false;
-    }
-
-    export function isExternalModuleImportDeclaration(node: Node) {
-        return node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference;
-    }
-
-    export function getExternalModuleImportDeclarationExpression(node: Node) {
-        Debug.assert(isExternalModuleImportDeclaration(node));
-        return (<ExternalModuleReference>(<ImportDeclaration>node).moduleReference).expression;
-    }
-
-    export function isInternalModuleImportDeclaration(node: Node) {
-        return node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).moduleReference.kind !== SyntaxKind.ExternalModuleReference;
-    }
-
-    export function hasDotDotDotToken(node: Node) {
-        return node && node.kind === SyntaxKind.Parameter && (<ParameterDeclaration>node).dotDotDotToken !== undefined;
-    }
-
-    export function hasQuestionToken(node: Node) {
-        if (node) {
-            switch (node.kind) {
-                case SyntaxKind.Parameter:
-                    return (<ParameterDeclaration>node).questionToken !== undefined;
-                case SyntaxKind.Method:
-                    return (<MethodDeclaration>node).questionToken !== undefined;
-                case SyntaxKind.ShorthandPropertyAssignment:
-                case SyntaxKind.PropertyAssignment:
-                case SyntaxKind.Property:
-                    return (<PropertyDeclaration>node).questionToken !== undefined;
-            }
-        }
-
-        return false;
-    }
-
-    export function hasRestParameters(s: SignatureDeclaration): boolean {
-        return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined;
-    }
-
-    export function isLiteralKind(kind: SyntaxKind): boolean {
-        return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken;
-    }
-
-    export function isTextualLiteralKind(kind: SyntaxKind): boolean {
-        return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
-    }
-
-    export function isTemplateLiteralKind(kind: SyntaxKind): boolean {
-        return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
-    }
-
-    export function isInAmbientContext(node: Node): boolean {
-        while (node) {
-            if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) return true;
-            node = node.parent;
-        }
-        return false;
-    }
-
-    export function isDeclaration(node: Node): boolean {
-        switch (node.kind) {
-            case SyntaxKind.TypeParameter:
-            case SyntaxKind.Parameter:
-            case SyntaxKind.VariableDeclaration:
-            case SyntaxKind.Property:
-            case SyntaxKind.PropertyAssignment:
-            case SyntaxKind.ShorthandPropertyAssignment:
-            case SyntaxKind.EnumMember:
-            case SyntaxKind.Method:
-            case SyntaxKind.FunctionDeclaration:
-            case SyntaxKind.GetAccessor:
-            case SyntaxKind.SetAccessor:
-            case SyntaxKind.Constructor:
-            case SyntaxKind.ClassDeclaration:
-            case SyntaxKind.InterfaceDeclaration:
-            case SyntaxKind.TypeAliasDeclaration:
-            case SyntaxKind.EnumDeclaration:
-            case SyntaxKind.ModuleDeclaration:
-            case SyntaxKind.ImportDeclaration:
-                return true;
-        }
-        return false;
-    }
-
-    export function isStatement(n: Node): boolean {
-        switch(n.kind) {
-            case SyntaxKind.BreakStatement:
-            case SyntaxKind.ContinueStatement:
-            case SyntaxKind.DebuggerStatement:
-            case SyntaxKind.DoStatement:
-            case SyntaxKind.ExpressionStatement:
-            case SyntaxKind.EmptyStatement:
-            case SyntaxKind.ForInStatement:
-            case SyntaxKind.ForStatement:
-            case SyntaxKind.IfStatement:
-            case SyntaxKind.LabeledStatement:
-            case SyntaxKind.ReturnStatement:
-            case SyntaxKind.SwitchStatement:
-            case SyntaxKind.ThrowKeyword:
-            case SyntaxKind.TryStatement:
-            case SyntaxKind.VariableStatement:
-            case SyntaxKind.WhileStatement:
-            case SyntaxKind.WithStatement:
-            case SyntaxKind.ExportAssignment:
-                return true;
-            default:
                 return false;
-        }
-    }
+            }
 
-    // True if the given identifier, string literal, or number literal is the name of a declaration node
-    export function isDeclarationOrFunctionExpressionOrCatchVariableName(name: Node): boolean {
-        if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
-            return false;
-        }
+            function ensureDirectoriesExist(directoryPath: string) {
+                if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
+                    var parentDirectory = getDirectoryPath(directoryPath);
+                    ensureDirectoriesExist(parentDirectory);
+                    sys.createDirectory(directoryPath);
+                }
+            }
 
-        var parent = name.parent;
-        if (isDeclaration(parent) || parent.kind === SyntaxKind.FunctionExpression) {
-            return (<Declaration>parent).name === name;
-        }
-
-        if (parent.kind === SyntaxKind.CatchClause) {
-            return (<CatchClause>parent).name === name;
-        }
-
-        return false;
-    }
-
-    export function getClassBaseTypeNode(node: ClassDeclaration) {
-        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
-        return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
-    }
-
-    export function getClassImplementedTypeNodes(node: ClassDeclaration) {
-        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
-        return heritageClause ? heritageClause.types : undefined;
-    }
-
-    export function getInterfaceBaseTypeNodes(node: InterfaceDeclaration) {
-        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
-        return heritageClause ? heritageClause.types : undefined;
-    }
-
-    export function getHeritageClause(clauses: NodeArray<HeritageClause>, kind: SyntaxKind) {
-        if (clauses) {
-            for (var i = 0, n = clauses.length; i < n; i++) {
-                if (clauses[i].token === kind) {
-                    return clauses[i];
+            try {
+                ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
+                sys.writeFile(fileName, data, writeByteOrderMark);
+            }
+            catch (e) {
+                if (onError) {
+                    onError(e.message);
                 }
             }
         }
 
-        return undefined;
+        return {
+            getSourceFile,
+            getDefaultLibFilename: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), options.target === ScriptTarget.ES6 ? "lib.es6.d.ts" : "lib.d.ts"),
+            writeFile,
+            getCurrentDirectory: () => currentDirectory || (currentDirectory = sys.getCurrentDirectory()),
+            useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
+            getCanonicalFileName,
+            getNewLine: () => sys.newLine
+        };
     }
 
-    export function tryResolveScriptReference(program: Program, sourceFile: SourceFile, reference: FileReference) {
-        if (!program.getCompilerOptions().noResolve) {
-            var referenceFileName = isRootedDiskPath(reference.filename) ? reference.filename : combinePaths(getDirectoryPath(sourceFile.filename), reference.filename);
-            referenceFileName = getNormalizedAbsolutePath(referenceFileName, program.getCompilerHost().getCurrentDirectory());
-            return program.getSourceFile(referenceFileName);
-        }
-    }
-
-    export function getAncestor(node: Node, kind: SyntaxKind): Node {
-        switch (kind) {
-            // special-cases that can be come first
-            case SyntaxKind.ClassDeclaration:
-                while (node) {
-                    switch (node.kind) {
-                        case SyntaxKind.ClassDeclaration:
-                            return <ClassDeclaration>node;
-                        case SyntaxKind.EnumDeclaration:
-                        case SyntaxKind.InterfaceDeclaration:
-                        case SyntaxKind.TypeAliasDeclaration:
-                        case SyntaxKind.ModuleDeclaration:
-                        case SyntaxKind.ImportDeclaration:
-                            // early exit cases - declarations cannot be nested in classes
-                            return undefined;
-                        default:
-                            node = node.parent;
-                            continue;
-                    }
-                }
-                break;
-            default:
-                while (node) {
-                    if (node.kind === kind) {
-                        return node;
-                    }
-                    node = node.parent;
-                }
-                break;
-        }
-
-        return undefined;
-    }
 
     const enum ParsingContext {
         SourceElements,          // Elements in source file
@@ -919,68 +392,6 @@ module ts {
         }
     };
 
-    export interface ReferencePathMatchResult {
-        fileReference?: FileReference
-        diagnosticMessage?: DiagnosticMessage
-        isNoDefaultLib?: boolean
-    }
-
-    export function getFileReferenceFromReferencePath(comment: string, commentRange: CommentRange): ReferencePathMatchResult {
-        var simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
-        var isNoDefaultLibRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/gim;
-        if (simpleReferenceRegEx.exec(comment)) {
-            if (isNoDefaultLibRegEx.exec(comment)) {
-                return {
-                    isNoDefaultLib: true
-                }
-            }
-            else {
-                var matchResult = fullTripleSlashReferencePathRegEx.exec(comment);
-                if (matchResult) {
-                    var start = commentRange.pos;
-                    var end = commentRange.end;
-                    return {
-                        fileReference: {
-                            pos: start,
-                            end: end,
-                            filename: matchResult[3]
-                        },
-                        isNoDefaultLib: false
-                    };
-                }
-                else {
-                    return {
-                        diagnosticMessage: Diagnostics.Invalid_reference_directive_syntax,
-                        isNoDefaultLib: false
-                    };
-                }
-            }
-        }
-        return undefined;
-    }
-
-    export function isKeyword(token: SyntaxKind): boolean {
-        return SyntaxKind.FirstKeyword <= token && token <= SyntaxKind.LastKeyword;
-    }
-
-    export function isTrivia(token: SyntaxKind) {
-        return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
-    }
-
-    export function isModifier(token: SyntaxKind): boolean {
-        switch (token) {
-            case SyntaxKind.PublicKeyword:
-            case SyntaxKind.PrivateKeyword:
-            case SyntaxKind.ProtectedKeyword:
-            case SyntaxKind.StaticKeyword:
-            case SyntaxKind.ExportKeyword:
-            case SyntaxKind.DeclareKeyword:
-            case SyntaxKind.ConstKeyword:
-                return true;
-        }
-        return false;
-    }
-
     function modifierToFlag(token: SyntaxKind): NodeFlags {
         switch (token) {
             case SyntaxKind.StaticKeyword: return NodeFlags.Static;
@@ -994,6 +405,18 @@ module ts {
         return 0;
     }
 
+    function isEvalOrArgumentsIdentifier(node: Node): boolean {
+        return node.kind === SyntaxKind.Identifier &&
+            ((<Identifier>node).text === "eval" || (<Identifier>node).text === "arguments");
+    }
+
+    /// Should be called only on prologue directives (isPrologueDirective(node) should be true)
+    function isUseStrictPrologueDirective(sourceFile: SourceFile, node: Node): boolean {
+        Debug.assert(isPrologueDirective(node));
+        var nodeText = getSourceTextOfNodeFromSourceFile(sourceFile,(<ExpressionStatement>node).expression);
+        return nodeText === '"use strict"' || nodeText === "'use strict'";
+    }
+
     export function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen: boolean = false): SourceFile {
         var token: SyntaxKind;
         var parsingContext: ParsingContext;
@@ -1651,7 +1074,7 @@ module ts {
                     // test elements only if we are not already in strict mode
                     if (checkForStrictMode && !inStrictModeContext()) {
                         if (isPrologueDirective(element)) {
-                            if (isUseStrictPrologueDirective(element)) {
+                            if (isUseStrictPrologueDirective(sourceFile, element)) {
                                 setStrictModeContext(true);
                                 checkForStrictMode = false;
                             }
diff --git a/src/compiler/sys.ts b/src/compiler/sys.ts
index e58d08589ba..27a8c305c4b 100644
--- a/src/compiler/sys.ts
+++ b/src/compiler/sys.ts
@@ -1,252 +1,255 @@
 
-interface System {
-    args: string[];
-    newLine: string;
-    useCaseSensitiveFileNames: boolean;
-    write(s: string): void;
-    readFile(fileName: string, encoding?: string): string;
-    writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void;
-    watchFile?(fileName: string, callback: (fileName: string) => void): FileWatcher;
-    resolvePath(path: string): string;
-    fileExists(path: string): boolean;
-    directoryExists(path: string): boolean;
-    createDirectory(directoryName: string): void;
-    getExecutingFilePath(): string;
-    getCurrentDirectory(): string;
-    getMemoryUsage?(): number;
-    exit(exitCode?: number): void;
-}
+module ts {
+    export interface System {
+        args: string[];
+        newLine: string;
+        useCaseSensitiveFileNames: boolean;
+        write(s: string): void;
+        readFile(fileName: string, encoding?: string): string;
+        writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void;
+        watchFile? (fileName: string, callback: (fileName: string) => void): FileWatcher;
+        resolvePath(path: string): string;
+        fileExists(path: string): boolean;
+        directoryExists(path: string): boolean;
+        createDirectory(directoryName: string): void;
+        getExecutingFilePath(): string;
+        getCurrentDirectory(): string;
+        getMemoryUsage? (): number;
+        exit(exitCode?: number): void;
+    }
 
-interface FileWatcher {
-    close(): void;
-}
+    export interface FileWatcher {
+        close(): void;
+    }
 
-declare var require: any;
-declare var module: any;
-declare var process: any;
-declare var global: any;
+    declare var require: any;
+    declare var module: any;
+    declare var process: any;
+    declare var global: any;
+    declare var __filename: string;
 
-var sys: System = (function () {
+    export var sys: System = (function () {
 
-    function getWScriptSystem(): System {
+        function getWScriptSystem(): System {
 
-        var fso = new ActiveXObject("Scripting.FileSystemObject");
+            var fso = new ActiveXObject("Scripting.FileSystemObject");
 
-        var fileStream = new ActiveXObject("ADODB.Stream");
-        fileStream.Type = 2 /*text*/;
+            var fileStream = new ActiveXObject("ADODB.Stream");
+            fileStream.Type = 2 /*text*/;
 
-        var binaryStream = new ActiveXObject("ADODB.Stream");
-        binaryStream.Type = 1 /*binary*/;
+            var binaryStream = new ActiveXObject("ADODB.Stream");
+            binaryStream.Type = 1 /*binary*/;
 
-        var args: string[] = [];
-        for (var i = 0; i < WScript.Arguments.length; i++) {
-            args[i] = WScript.Arguments.Item(i);
-        }
-
-        function readFile(fileName: string, encoding?: string): string {
-            if (!fso.FileExists(fileName)) {
-                return undefined;
+            var args: string[] = [];
+            for (var i = 0; i < WScript.Arguments.length; i++) {
+                args[i] = WScript.Arguments.Item(i);
             }
-            fileStream.Open();
-            try {
-                if (encoding) {
-                    fileStream.Charset = encoding;
-                    fileStream.LoadFromFile(fileName);
+
+            function readFile(fileName: string, encoding?: string): string {
+                if (!fso.FileExists(fileName)) {
+                    return undefined;
                 }
-                else {
-                    // Load file and read the first two bytes into a string with no interpretation
-                    fileStream.Charset = "x-ansi";
-                    fileStream.LoadFromFile(fileName);
-                    var bom = fileStream.ReadText(2) || "";
-                    // Position must be at 0 before encoding can be changed
-                    fileStream.Position = 0;
-                    // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8
-                    fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8";
-                }
-                // ReadText method always strips byte order mark from resulting string
-                return fileStream.ReadText();
-            }
-            catch (e) {
-                throw e;
-            }
-            finally {
-                fileStream.Close();
-            }
-        }
-
-        function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
-            fileStream.Open();
-            binaryStream.Open();
-            try {
-                // Write characters in UTF-8 encoding
-                fileStream.Charset = "utf-8";
-                fileStream.WriteText(data);
-                // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM).
-                // If not, start from position 0, as the BOM will be added automatically when charset==utf8.
-                if (writeByteOrderMark) {
-                    fileStream.Position = 0;
-                }
-                else {
-                    fileStream.Position = 3;
-                }
-                fileStream.CopyTo(binaryStream);
-                binaryStream.SaveToFile(fileName, 2 /*overwrite*/);
-            }
-            finally {
-                binaryStream.Close();
-                fileStream.Close();
-            }
-        }
-
-        return {
-            args,
-            newLine: "\r\n",
-            useCaseSensitiveFileNames: false,
-            write(s: string): void {
-                WScript.StdOut.Write(s);
-            },
-            readFile,
-            writeFile,
-            resolvePath(path: string): string {
-                return fso.GetAbsolutePathName(path);
-            },
-            fileExists(path: string): boolean {
-                return fso.FileExists(path);
-            },
-            directoryExists(path: string) {
-                return fso.FolderExists(path);
-            },
-            createDirectory(directoryName: string) {
-                if (!this.directoryExists(directoryName)) {
-                    fso.CreateFolder(directoryName);
-                }
-            },
-            getExecutingFilePath() {
-                return WScript.ScriptFullName;
-            },
-            getCurrentDirectory() {
-                return new ActiveXObject("WScript.Shell").CurrentDirectory;
-            },
-            exit(exitCode?: number): void {
+                fileStream.Open();
                 try {
-                    WScript.Quit(exitCode);
+                    if (encoding) {
+                        fileStream.Charset = encoding;
+                        fileStream.LoadFromFile(fileName);
+                    }
+                    else {
+                        // Load file and read the first two bytes into a string with no interpretation
+                        fileStream.Charset = "x-ansi";
+                        fileStream.LoadFromFile(fileName);
+                        var bom = fileStream.ReadText(2) || "";
+                        // Position must be at 0 before encoding can be changed
+                        fileStream.Position = 0;
+                        // [0xFF,0xFE] and [0xFE,0xFF] mean utf-16 (little or big endian), otherwise default to utf-8
+                        fileStream.Charset = bom.length >= 2 && (bom.charCodeAt(0) === 0xFF && bom.charCodeAt(1) === 0xFE || bom.charCodeAt(0) === 0xFE && bom.charCodeAt(1) === 0xFF) ? "unicode" : "utf-8";
+                    }
+                    // ReadText method always strips byte order mark from resulting string
+                    return fileStream.ReadText();
                 }
                 catch (e) {
+                    throw e;
+                }
+                finally {
+                    fileStream.Close();
                 }
             }
-        };
-    }
-    function getNodeSystem(): System {
-        var _fs = require("fs");
-        var _path = require("path");
-        var _os = require('os');
 
-        var platform: string = _os.platform();
-        // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
-        var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
-
-        function readFile(fileName: string, encoding?: string): string {
-            if (!_fs.existsSync(fileName)) {
-                return undefined;
-            }
-            var buffer = _fs.readFileSync(fileName);
-            var len = buffer.length;
-            if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
-                // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
-                // flip all byte pairs and treat as little endian.
-                len &= ~1;
-                for (var i = 0; i < len; i += 2) {
-                    var temp = buffer[i];
-                    buffer[i] = buffer[i + 1];
-                    buffer[i + 1] = temp;
-                }
-                return buffer.toString("utf16le", 2);
-            }
-            if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) {
-                // Little endian UTF-16 byte order mark detected
-                return buffer.toString("utf16le", 2);
-            }
-            if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
-                // UTF-8 byte order mark detected
-                return buffer.toString("utf8", 3);
-            }
-            // Default is UTF-8 with no byte order mark
-            return buffer.toString("utf8");
-        }
-
-        function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
-            // If a BOM is required, emit one
-            if (writeByteOrderMark) {
-                data = '\uFEFF' + data;
-            }
-
-            _fs.writeFileSync(fileName, data, "utf8");
-        }
-
-        return {
-            args: process.argv.slice(2),
-            newLine: _os.EOL,
-            useCaseSensitiveFileNames: useCaseSensitiveFileNames,
-            write(s: string): void {
-               // 1 is a standard descriptor for stdout
-               _fs.writeSync(1, s);
-            },
-            readFile,
-            writeFile,
-            watchFile: (fileName, callback) => {
-                // watchFile polls a file every 250ms, picking up file notifications.
-                _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
-
-                return {
-                    close() { _fs.unwatchFile(fileName, fileChanged); }
-                };
-
-                function fileChanged(curr: any, prev: any) {
-                    if (+curr.mtime <= +prev.mtime) {
-                        return;
+            function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
+                fileStream.Open();
+                binaryStream.Open();
+                try {
+                    // Write characters in UTF-8 encoding
+                    fileStream.Charset = "utf-8";
+                    fileStream.WriteText(data);
+                    // If we don't want the BOM, then skip it by setting the starting location to 3 (size of BOM).
+                    // If not, start from position 0, as the BOM will be added automatically when charset==utf8.
+                    if (writeByteOrderMark) {
+                        fileStream.Position = 0;
                     }
-
-                    callback(fileName);
-                };
-            },
-            resolvePath: function (path: string): string {
-                return _path.resolve(path);
-            },
-            fileExists(path: string): boolean {
-                return _fs.existsSync(path);
-            },
-            directoryExists(path: string) {
-                return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
-            },
-            createDirectory(directoryName: string) {
-                if (!this.directoryExists(directoryName)) {
-                    _fs.mkdirSync(directoryName);
+                    else {
+                        fileStream.Position = 3;
+                    }
+                    fileStream.CopyTo(binaryStream);
+                    binaryStream.SaveToFile(fileName, 2 /*overwrite*/);
                 }
-            },
-            getExecutingFilePath() {
-                return process.mainModule.filename;
-            },
-            getCurrentDirectory() {
-                return (<any>process).cwd();
-            },
-            getMemoryUsage() {
-                if (global.gc) {
-                    global.gc();
+                finally {
+                    binaryStream.Close();
+                    fileStream.Close();
                 }
-                return process.memoryUsage().heapUsed;
-            },
-            exit(exitCode?: number): void {
-                process.exit(exitCode);
             }
-        };
-    }
-    if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
-        return getWScriptSystem();
-    }
-    else if (typeof module !== "undefined" && module.exports) {
-        return getNodeSystem();
-    }
-    else {
-        return undefined; // Unsupported host
-    }
-})();
+
+            return {
+                args,
+                newLine: "\r\n",
+                useCaseSensitiveFileNames: false,
+                write(s: string): void {
+                    WScript.StdOut.Write(s);
+                },
+                readFile,
+                writeFile,
+                resolvePath(path: string): string {
+                    return fso.GetAbsolutePathName(path);
+                },
+                fileExists(path: string): boolean {
+                    return fso.FileExists(path);
+                },
+                directoryExists(path: string) {
+                    return fso.FolderExists(path);
+                },
+                createDirectory(directoryName: string) {
+                    if (!this.directoryExists(directoryName)) {
+                        fso.CreateFolder(directoryName);
+                    }
+                },
+                getExecutingFilePath() {
+                    return WScript.ScriptFullName;
+                },
+                getCurrentDirectory() {
+                    return new ActiveXObject("WScript.Shell").CurrentDirectory;
+                },
+                exit(exitCode?: number): void {
+                    try {
+                        WScript.Quit(exitCode);
+                    }
+                    catch (e) {
+                    }
+                }
+            };
+        }
+        function getNodeSystem(): System {
+            var _fs = require("fs");
+            var _path = require("path");
+            var _os = require('os');
+
+            var platform: string = _os.platform();
+            // win32\win64 are case insensitive platforms, MacOS (darwin) by default is also case insensitive
+            var useCaseSensitiveFileNames = platform !== "win32" && platform !== "win64" && platform !== "darwin";
+
+            function readFile(fileName: string, encoding?: string): string {
+                if (!_fs.existsSync(fileName)) {
+                    return undefined;
+                }
+                var buffer = _fs.readFileSync(fileName);
+                var len = buffer.length;
+                if (len >= 2 && buffer[0] === 0xFE && buffer[1] === 0xFF) {
+                    // Big endian UTF-16 byte order mark detected. Since big endian is not supported by node.js,
+                    // flip all byte pairs and treat as little endian.
+                    len &= ~1;
+                    for (var i = 0; i < len; i += 2) {
+                        var temp = buffer[i];
+                        buffer[i] = buffer[i + 1];
+                        buffer[i + 1] = temp;
+                    }
+                    return buffer.toString("utf16le", 2);
+                }
+                if (len >= 2 && buffer[0] === 0xFF && buffer[1] === 0xFE) {
+                    // Little endian UTF-16 byte order mark detected
+                    return buffer.toString("utf16le", 2);
+                }
+                if (len >= 3 && buffer[0] === 0xEF && buffer[1] === 0xBB && buffer[2] === 0xBF) {
+                    // UTF-8 byte order mark detected
+                    return buffer.toString("utf8", 3);
+                }
+                // Default is UTF-8 with no byte order mark
+                return buffer.toString("utf8");
+            }
+
+            function writeFile(fileName: string, data: string, writeByteOrderMark?: boolean): void {
+                // If a BOM is required, emit one
+                if (writeByteOrderMark) {
+                    data = '\uFEFF' + data;
+                }
+
+                _fs.writeFileSync(fileName, data, "utf8");
+            }
+
+            return {
+                args: process.argv.slice(2),
+                newLine: _os.EOL,
+                useCaseSensitiveFileNames: useCaseSensitiveFileNames,
+                write(s: string): void {
+                    // 1 is a standard descriptor for stdout
+                    _fs.writeSync(1, s);
+                },
+                readFile,
+                writeFile,
+                watchFile: (fileName, callback) => {
+                    // watchFile polls a file every 250ms, picking up file notifications.
+                    _fs.watchFile(fileName, { persistent: true, interval: 250 }, fileChanged);
+
+                    return {
+                        close() { _fs.unwatchFile(fileName, fileChanged); }
+                    };
+
+                    function fileChanged(curr: any, prev: any) {
+                        if (+curr.mtime <= +prev.mtime) {
+                            return;
+                        }
+
+                        callback(fileName);
+                    };
+                },
+                resolvePath: function (path: string): string {
+                    return _path.resolve(path);
+                },
+                fileExists(path: string): boolean {
+                    return _fs.existsSync(path);
+                },
+                directoryExists(path: string) {
+                    return _fs.existsSync(path) && _fs.statSync(path).isDirectory();
+                },
+                createDirectory(directoryName: string) {
+                    if (!this.directoryExists(directoryName)) {
+                        _fs.mkdirSync(directoryName);
+                    }
+                },
+                getExecutingFilePath() {
+                    return __filename;
+                },
+                getCurrentDirectory() {
+                    return process.cwd();
+                },
+                getMemoryUsage() {
+                    if (global.gc) {
+                        global.gc();
+                    }
+                    return process.memoryUsage().heapUsed;
+                },
+                exit(exitCode?: number): void {
+                    process.exit(exitCode);
+                }
+            };
+        }
+        if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
+            return getWScriptSystem();
+        }
+        else if (typeof module !== "undefined" && module.exports) {
+            return getNodeSystem();
+        }
+        else {
+            return undefined; // Unsupported host
+        }
+    })();
+}
\ No newline at end of file
diff --git a/src/compiler/tsc.ts b/src/compiler/tsc.ts
index fbe596ee0f7..bc4d48b7513 100644
--- a/src/compiler/tsc.ts
+++ b/src/compiler/tsc.ts
@@ -133,75 +133,6 @@ module ts {
         reportStatisticalValue(name, (time / 1000).toFixed(2) + "s");
     }
 
-    function createCompilerHost(options: CompilerOptions): CompilerHost {
-        var currentDirectory: string;
-        var existingDirectories: Map<boolean> = {};
-
-        function getCanonicalFileName(fileName: string): string {
-            // if underlying system can distinguish between two files whose names differs only in cases then file name already in canonical form.
-            // otherwise use toLowerCase as a canonical form.
-            return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
-        }
-        
-        // returned by CScript sys environment
-        var unsupportedFileEncodingErrorCode = -2147024809;
-        
-        function getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile {
-            try {
-                var text = sys.readFile(filename, options.charset);
-            }
-            catch (e) {
-                if (onError) {
-                    onError(e.number === unsupportedFileEncodingErrorCode ? 
-                                getDiagnosticText(Diagnostics.Unsupported_file_encoding) :
-                                e.message);
-                }
-                text = "";
-            }
-            return text !== undefined ? createSourceFile(filename, text, languageVersion, /*version:*/ "0") : undefined;
-        }
-
-        function writeFile(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) {
-
-            function directoryExists(directoryPath: string): boolean {
-                if (hasProperty(existingDirectories, directoryPath)) {
-                    return true;
-                }
-                if (sys.directoryExists(directoryPath)) {
-                    existingDirectories[directoryPath] = true;
-                    return true;
-                }
-                return false;
-            }
-
-            function ensureDirectoriesExist(directoryPath: string) {
-                if (directoryPath.length > getRootLength(directoryPath) && !directoryExists(directoryPath)) {
-                    var parentDirectory = getDirectoryPath(directoryPath);
-                    ensureDirectoriesExist(parentDirectory);
-                    sys.createDirectory(directoryPath);
-                }
-            }
-
-            try {
-                ensureDirectoriesExist(getDirectoryPath(normalizePath(fileName)));
-                sys.writeFile(fileName, data, writeByteOrderMark);
-            }
-            catch (e) {
-                if (onError) onError(e.message);
-            }
-        }
-
-        return {
-            getSourceFile,
-            getDefaultLibFilename: options => combinePaths(getDirectoryPath(normalizePath(sys.getExecutingFilePath())), options.target === ScriptTarget.ES6 ? "lib.es6.d.ts" : "lib.d.ts"),
-            writeFile,
-            getCurrentDirectory: () => currentDirectory || (currentDirectory = sys.getCurrentDirectory()),
-            useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
-            getCanonicalFileName,
-            getNewLine: () => sys.newLine
-        };
-    }
-
     export function executeCommandLine(args: string[]): void {
         var commandLine = parseCommandLine(args);
         var compilerOptions = commandLine.options;
@@ -447,12 +378,12 @@ module ts {
             var usageText = " ";
             if (option.shortName) {
                 usageText += "-" + option.shortName;
-                usageText += getParamName(option);
+                usageText += getParamType(option);
                 usageText += ", ";
             }
 
             usageText += "--" + option.name;
-            usageText += getParamName(option);
+            usageText += getParamType(option);
 
             usageColumn.push(usageText);
             descriptionColumn.push(getDiagnosticText(option.description));
@@ -477,9 +408,9 @@ module ts {
         sys.write(output);
         return;
 
-        function getParamName(option: CommandLineOption) {
-            if (option.paramName !== undefined) {
-                return " " + getDiagnosticText(option.paramName);
+        function getParamType(option: CommandLineOption) {
+            if (option.paramType !== undefined) {
+                return " " + getDiagnosticText(option.paramType);
             }
             return "";
         }
@@ -490,4 +421,4 @@ module ts {
     }
 }
 
-ts.executeCommandLine(sys.args);
+ts.executeCommandLine(ts.sys.args);
diff --git a/src/compiler/types.ts b/src/compiler/types.ts
index 1ef26dd6f54..24d67370b2d 100644
--- a/src/compiler/types.ts
+++ b/src/compiler/types.ts
@@ -1,6 +1,9 @@
 /// <reference path="core.ts"/>
 
 module ts {
+    export interface Map<T> {
+        [index: string]: T;
+    }
 
     export interface TextRange {
         pos: number;
@@ -1201,7 +1204,6 @@ module ts {
         StringLike = String | StringLiteral,
         NumberLike = Number | Enum,
         ObjectType = Class | Interface | Reference | Tuple | Anonymous,
-        Structured = Any | ObjectType | Union | TypeParameter
     }
 
     // Properties common to all types
@@ -1356,6 +1358,7 @@ module ts {
     }
 
     export interface CompilerOptions {
+        allowNonTsExtensions?: boolean;
         charset?: string;
         codepage?: number;
         declaration?: boolean;
@@ -1373,14 +1376,14 @@ module ts {
         noResolve?: boolean;
         out?: string;
         outDir?: string;
+        preserveConstEnums?: boolean;
         removeComments?: boolean;
         sourceMap?: boolean;
         sourceRoot?: string;
+        suppressImplicitAnyIndexErrors?: boolean;
         target?: ScriptTarget;
         version?: boolean;
         watch?: boolean;
-        preserveConstEnums?: boolean;
-        allowNonTsExtensions?: boolean;
         [option: string]: string | number | boolean;
     }
 
@@ -1417,7 +1420,7 @@ module ts {
         type: string | Map<number>;         // "string", "number", "boolean", or an object literal mapping named values to actual values
         shortName?: string;                 // A short mnemonic for convenience - for instance, 'h' can be used in place of 'help'.
         description?: DiagnosticMessage;    // The message describing what the command line switch does
-        paramName?: DiagnosticMessage;      // The name to be used for a non-boolean option's parameter.
+        paramType?: DiagnosticMessage;      // The name to be used for a non-boolean option's parameter.
         error?: DiagnosticMessage;          // The error given when the argument does not fit a customized 'type'.
     }
 
@@ -1555,7 +1558,7 @@ module ts {
         tab = 0x09,                   // \t
         verticalTab = 0x0B,           // \v
     }
-    
+
     export interface CancellationToken {
         isCancellationRequested(): boolean;
     }
diff --git a/src/compiler/utilities.ts b/src/compiler/utilities.ts
new file mode 100644
index 00000000000..fb88b818917
--- /dev/null
+++ b/src/compiler/utilities.ts
@@ -0,0 +1,709 @@
+/// <reference path="types.ts" />
+
+module ts {
+    export interface ReferencePathMatchResult {
+        fileReference?: FileReference
+        diagnosticMessage?: DiagnosticMessage
+        isNoDefaultLib?: boolean
+    }
+
+    export function getDeclarationOfKind(symbol: Symbol, kind: SyntaxKind): Declaration {
+        var declarations = symbol.declarations;
+        for (var i = 0; i < declarations.length; i++) {
+            var declaration = declarations[i];
+            if (declaration.kind === kind) {
+                return declaration;
+            }
+        }
+
+        return undefined;
+    }
+
+    export interface StringSymbolWriter extends SymbolWriter {
+        string(): string;
+    }
+
+    // Pool writers to avoid needing to allocate them for every symbol we write.
+    var stringWriters: StringSymbolWriter[] = [];
+    export function getSingleLineStringWriter(): StringSymbolWriter {
+        if (stringWriters.length == 0) {
+            var str = "";
+
+            var writeText: (text: string) => void = text => str += text;
+            return {
+                string: () => str,
+                writeKeyword: writeText,
+                writeOperator: writeText,
+                writePunctuation: writeText,
+                writeSpace: writeText,
+                writeStringLiteral: writeText,
+                writeParameter: writeText,
+                writeSymbol: writeText,
+
+                // Completely ignore indentation for string writers.  And map newlines to
+                // a single space.
+                writeLine: () => str += " ",
+                increaseIndent: () => { },
+                decreaseIndent: () => { },
+                clear: () => str = "",
+                trackSymbol: () => { }
+            };
+        }
+
+        return stringWriters.pop();
+    }
+
+    export function releaseStringWriter(writer: StringSymbolWriter) {
+        writer.clear()
+        stringWriters.push(writer);
+    }
+
+    export function getFullWidth(node: Node) {
+        return node.end - node.pos;
+    }
+
+    export function hasFlag(val: number, flag: number): boolean {
+        return (val & flag) !== 0;
+    }
+
+    // Returns true if this node contains a parse error anywhere underneath it.
+    export function containsParseError(node: Node): boolean {
+        if (!hasFlag(node.parserContextFlags, ParserContextFlags.HasPropagatedChildContainsErrorFlag)) {
+            // A node is considered to contain a parse error if:
+            //  a) the parser explicitly marked that it had an error
+            //  b) any of it's children reported that it had an error.
+            var val = hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError) ||
+                forEachChild(node, containsParseError);
+
+            // If so, mark ourselves accordingly. 
+            if (val) {
+                node.parserContextFlags |= ParserContextFlags.ContainsError;
+            }
+
+            // Also mark that we've propogated the child information to this node.  This way we can
+            // always consult the bit directly on this node without needing to check its children
+            // again.
+            node.parserContextFlags |= ParserContextFlags.HasPropagatedChildContainsErrorFlag;
+        }
+
+        return hasFlag(node.parserContextFlags, ParserContextFlags.ContainsError);
+    }
+
+    export function getSourceFileOfNode(node: Node): SourceFile {
+        while (node && node.kind !== SyntaxKind.SourceFile) {
+            node = node.parent;
+        }
+        return <SourceFile>node;
+    }
+
+    // This is a useful function for debugging purposes.
+    export function nodePosToString(node: Node): string {
+        var file = getSourceFileOfNode(node);
+        var loc = file.getLineAndCharacterFromPosition(node.pos);
+        return file.filename + "(" + loc.line + "," + loc.character + ")";
+    }
+
+    export function getStartPosOfNode(node: Node): number {
+        return node.pos;
+    }
+
+    export function isMissingNode(node: Node) {
+        return node.pos === node.end && node.kind !== SyntaxKind.EndOfFileToken;
+    }
+
+    export function getTokenPosOfNode(node: Node, sourceFile?: SourceFile): number {
+        // With nodes that have no width (i.e. 'Missing' nodes), we actually *don't*
+        // want to skip trivia because this will launch us forward to the next token.
+        if (isMissingNode(node)) {
+            return node.pos;
+        }
+
+        return skipTrivia((sourceFile || getSourceFileOfNode(node)).text, node.pos);
+    }
+
+    export function getSourceTextOfNodeFromSourceFile(sourceFile: SourceFile, node: Node): string {
+        if (isMissingNode(node)) {
+            return "";
+        }
+
+        var text = sourceFile.text;
+        return text.substring(skipTrivia(text, node.pos), node.end);
+    }
+
+    export function getTextOfNodeFromSourceText(sourceText: string, node: Node): string {
+        if (isMissingNode(node)) {
+            return "";
+        }
+
+        return sourceText.substring(skipTrivia(sourceText, node.pos), node.end);
+    }
+
+    export function getTextOfNode(node: Node): string {
+        return getSourceTextOfNodeFromSourceFile(getSourceFileOfNode(node), node);
+    }
+
+    // Add an extra underscore to identifiers that start with two underscores to avoid issues with magic names like '__proto__'
+    export function escapeIdentifier(identifier: string): string {
+        return identifier.length >= 2 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ ? "_" + identifier : identifier;
+    }
+
+    // Remove extra underscore from escaped identifier
+    export function unescapeIdentifier(identifier: string): string {
+        return identifier.length >= 3 && identifier.charCodeAt(0) === CharacterCodes._ && identifier.charCodeAt(1) === CharacterCodes._ && identifier.charCodeAt(2) === CharacterCodes._ ? identifier.substr(1) : identifier;
+    }
+
+    // Return display name of an identifier
+    // Computed property names will just be emitted as "[<expr>]", where <expr> is the source
+    // text of the expression in the computed property.
+    export function declarationNameToString(name: DeclarationName) {
+        return getFullWidth(name) === 0 ? "(Missing)" : getTextOfNode(name);
+    }
+
+    export function createDiagnosticForNode(node: Node, message: DiagnosticMessage, arg0?: any, arg1?: any, arg2?: any): Diagnostic {
+        node = getErrorSpanForNode(node);
+        var file = getSourceFileOfNode(node);
+
+        var start = getTokenPosOfNode(node, file);
+        var length = node.end - start;
+
+        return createFileDiagnostic(file, start, length, message, arg0, arg1, arg2);
+    }
+
+    export function createDiagnosticForNodeFromMessageChain(node: Node, messageChain: DiagnosticMessageChain, newLine: string): Diagnostic {
+        node = getErrorSpanForNode(node);
+        var file = getSourceFileOfNode(node);
+        var start = skipTrivia(file.text, node.pos);
+        var length = node.end - start;
+        return flattenDiagnosticChain(file, start, length, messageChain, newLine);
+    }
+
+    export function getErrorSpanForNode(node: Node): Node {
+        var errorSpan: Node;
+        switch (node.kind) {
+            // This list is a work in progress. Add missing node kinds to improve their error
+            // spans.
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.EnumDeclaration:
+            case SyntaxKind.EnumMember:
+                errorSpan = (<Declaration>node).name;
+                break;
+        }
+
+        // We now have the ideal error span, but it may be a node that is optional and absent
+        // (e.g. the name of a function expression), in which case errorSpan will be undefined.
+        // Alternatively, it might be required and missing (e.g. the name of a module), in which
+        // case its pos will equal its end (length 0). In either of these cases, we should fall
+        // back to the original node that the error was issued on.
+        return errorSpan && errorSpan.pos < errorSpan.end ? errorSpan : node;
+    }
+
+    export function isExternalModule(file: SourceFile): boolean {
+        return file.externalModuleIndicator !== undefined;
+    }
+
+    export function isDeclarationFile(file: SourceFile): boolean {
+        return (file.flags & NodeFlags.DeclarationFile) !== 0;
+    }
+
+    export function isConstEnumDeclaration(node: Node): boolean {
+        return node.kind === SyntaxKind.EnumDeclaration && isConst(node);
+    }
+
+    export function isConst(node: Node): boolean {
+        return !!(node.flags & NodeFlags.Const);
+    }
+
+    export function isLet(node: Node): boolean {
+        return !!(node.flags & NodeFlags.Let);
+    }
+
+    export function isPrologueDirective(node: Node): boolean {
+        return node.kind === SyntaxKind.ExpressionStatement && (<ExpressionStatement>node).expression.kind === SyntaxKind.StringLiteral;
+    }
+
+    export function getLeadingCommentRangesOfNode(node: Node, sourceFileOfNode?: SourceFile) {
+        sourceFileOfNode = sourceFileOfNode || getSourceFileOfNode(node);
+
+        // If parameter/type parameter, the prev token trailing comments are part of this node too
+        if (node.kind === SyntaxKind.Parameter || node.kind === SyntaxKind.TypeParameter) {
+            // e.g.   (/** blah */ a, /** blah */ b);
+            return concatenate(getTrailingCommentRanges(sourceFileOfNode.text, node.pos),
+                // e.g.:     (
+                //            /** blah */ a,
+                //            /** blah */ b);
+                getLeadingCommentRanges(sourceFileOfNode.text, node.pos));
+        }
+        else {
+            return getLeadingCommentRanges(sourceFileOfNode.text, node.pos);
+        }
+    }
+
+    export function getJsDocComments(node: Node, sourceFileOfNode: SourceFile) {
+        return filter(getLeadingCommentRangesOfNode(node, sourceFileOfNode), isJsDocComment);
+
+        function isJsDocComment(comment: CommentRange) {
+            // True if the comment starts with '/**' but not if it is '/**/'
+            return sourceFileOfNode.text.charCodeAt(comment.pos + 1) === CharacterCodes.asterisk &&
+                sourceFileOfNode.text.charCodeAt(comment.pos + 2) === CharacterCodes.asterisk &&
+                sourceFileOfNode.text.charCodeAt(comment.pos + 3) !== CharacterCodes.slash;
+        }
+    }
+
+    export var fullTripleSlashReferencePathRegEx = /^(\/\/\/\s*<reference\s+path\s*=\s*)('|")(.+?)\2.*?\/>/
+
+
+    // Warning: This has the same semantics as the forEach family of functions,
+    //          in that traversal terminates in the event that 'visitor' supplies a truthy value.
+    export function forEachReturnStatement<T>(body: Block, visitor: (stmt: ReturnStatement) => T): T {
+
+        return traverse(body);
+
+        function traverse(node: Node): T {
+            switch (node.kind) {
+                case SyntaxKind.ReturnStatement:
+                    return visitor(<ReturnStatement>node);
+                case SyntaxKind.Block:
+                case SyntaxKind.IfStatement:
+                case SyntaxKind.DoStatement:
+                case SyntaxKind.WhileStatement:
+                case SyntaxKind.ForStatement:
+                case SyntaxKind.ForInStatement:
+                case SyntaxKind.WithStatement:
+                case SyntaxKind.SwitchStatement:
+                case SyntaxKind.CaseClause:
+                case SyntaxKind.DefaultClause:
+                case SyntaxKind.LabeledStatement:
+                case SyntaxKind.TryStatement:
+                case SyntaxKind.TryBlock:
+                case SyntaxKind.CatchClause:
+                case SyntaxKind.FinallyBlock:
+                    return forEachChild(node, traverse);
+            }
+        }
+    }
+
+    export function isAnyFunction(node: Node): boolean {
+        if (node) {
+            switch (node.kind) {
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.ArrowFunction:
+                case SyntaxKind.Method:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.Constructor:
+                    return true;
+            }
+        }
+
+        return false;
+    }
+
+    export function isFunctionBlock(node: Node) {
+        return node !== undefined && node.kind === SyntaxKind.Block && isAnyFunction(node.parent);
+    }
+
+    export function isObjectLiteralMethod(node: Node) {
+        return node !== undefined && node.kind === SyntaxKind.Method && node.parent.kind === SyntaxKind.ObjectLiteralExpression;
+    }
+
+    export function getContainingFunction(node: Node): FunctionLikeDeclaration {
+        while (true) {
+            node = node.parent;
+            if (!node || isAnyFunction(node)) {
+                return <FunctionLikeDeclaration>node;
+            }
+        }
+    }
+
+    export function getThisContainer(node: Node, includeArrowFunctions: boolean): Node {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case SyntaxKind.ArrowFunction:
+                    if (!includeArrowFunctions) {
+                        continue;
+                    }
+                // Fall through
+                case SyntaxKind.FunctionDeclaration:
+                case SyntaxKind.FunctionExpression:
+                case SyntaxKind.ModuleDeclaration:
+                case SyntaxKind.Property:
+                case SyntaxKind.Method:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                case SyntaxKind.EnumDeclaration:
+                case SyntaxKind.SourceFile:
+                    return node;
+            }
+        }
+    }
+
+    export function getSuperContainer(node: Node): Node {
+        while (true) {
+            node = node.parent;
+            if (!node) {
+                return undefined;
+            }
+            switch (node.kind) {
+                case SyntaxKind.Property:
+                case SyntaxKind.Method:
+                case SyntaxKind.Constructor:
+                case SyntaxKind.GetAccessor:
+                case SyntaxKind.SetAccessor:
+                    return node;
+            }
+        }
+    }
+
+    export function getInvokedExpression(node: CallLikeExpression): Expression {
+        if (node.kind === SyntaxKind.TaggedTemplateExpression) {
+            return (<TaggedTemplateExpression>node).tag;
+        }
+        
+        // Will either be a CallExpression or NewExpression.
+        return (<CallExpression>node).expression;
+    }
+
+    export function isExpression(node: Node): boolean {
+        switch (node.kind) {
+            case SyntaxKind.ThisKeyword:
+            case SyntaxKind.SuperKeyword:
+            case SyntaxKind.NullKeyword:
+            case SyntaxKind.TrueKeyword:
+            case SyntaxKind.FalseKeyword:
+            case SyntaxKind.RegularExpressionLiteral:
+            case SyntaxKind.ArrayLiteralExpression:
+            case SyntaxKind.ObjectLiteralExpression:
+            case SyntaxKind.PropertyAccessExpression:
+            case SyntaxKind.ElementAccessExpression:
+            case SyntaxKind.CallExpression:
+            case SyntaxKind.NewExpression:
+            case SyntaxKind.TaggedTemplateExpression:
+            case SyntaxKind.TypeAssertionExpression:
+            case SyntaxKind.ParenthesizedExpression:
+            case SyntaxKind.FunctionExpression:
+            case SyntaxKind.ArrowFunction:
+            case SyntaxKind.VoidExpression:
+            case SyntaxKind.DeleteExpression:
+            case SyntaxKind.TypeOfExpression:
+            case SyntaxKind.PrefixUnaryExpression:
+            case SyntaxKind.PostfixUnaryExpression:
+            case SyntaxKind.BinaryExpression:
+            case SyntaxKind.ConditionalExpression:
+            case SyntaxKind.TemplateExpression:
+            case SyntaxKind.NoSubstitutionTemplateLiteral:
+            case SyntaxKind.OmittedExpression:
+                return true;
+            case SyntaxKind.QualifiedName:
+                while (node.parent.kind === SyntaxKind.QualifiedName) {
+                    node = node.parent;
+                }
+
+                return node.parent.kind === SyntaxKind.TypeQuery;
+            case SyntaxKind.Identifier:
+                if (node.parent.kind === SyntaxKind.TypeQuery) {
+                    return true;
+                }
+            // fall through
+            case SyntaxKind.NumericLiteral:
+            case SyntaxKind.StringLiteral:
+                var parent = node.parent;
+                switch (parent.kind) {
+                    case SyntaxKind.VariableDeclaration:
+                    case SyntaxKind.Parameter:
+                    case SyntaxKind.Property:
+                    case SyntaxKind.EnumMember:
+                    case SyntaxKind.PropertyAssignment:
+                        return (<VariableDeclaration>parent).initializer === node;
+                    case SyntaxKind.ExpressionStatement:
+                    case SyntaxKind.IfStatement:
+                    case SyntaxKind.DoStatement:
+                    case SyntaxKind.WhileStatement:
+                    case SyntaxKind.ReturnStatement:
+                    case SyntaxKind.WithStatement:
+                    case SyntaxKind.SwitchStatement:
+                    case SyntaxKind.CaseClause:
+                    case SyntaxKind.ThrowStatement:
+                    case SyntaxKind.SwitchStatement:
+                        return (<ExpressionStatement>parent).expression === node;
+                    case SyntaxKind.ForStatement:
+                        return (<ForStatement>parent).initializer === node ||
+                            (<ForStatement>parent).condition === node ||
+                            (<ForStatement>parent).iterator === node;
+                    case SyntaxKind.ForInStatement:
+                        return (<ForInStatement>parent).variable === node ||
+                            (<ForInStatement>parent).expression === node;
+                    case SyntaxKind.TypeAssertionExpression:
+                        return node === (<TypeAssertion>parent).expression;
+                    case SyntaxKind.TemplateSpan:
+                        return node === (<TemplateSpan>parent).expression;
+                    default:
+                        if (isExpression(parent)) {
+                            return true;
+                        }
+                }
+        }
+        return false;
+    }
+
+    export function isExternalModuleImportDeclaration(node: Node) {
+        return node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).moduleReference.kind === SyntaxKind.ExternalModuleReference;
+    }
+
+    export function getExternalModuleImportDeclarationExpression(node: Node) {
+        Debug.assert(isExternalModuleImportDeclaration(node));
+        return (<ExternalModuleReference>(<ImportDeclaration>node).moduleReference).expression;
+    }
+
+    export function isInternalModuleImportDeclaration(node: Node) {
+        return node.kind === SyntaxKind.ImportDeclaration && (<ImportDeclaration>node).moduleReference.kind !== SyntaxKind.ExternalModuleReference;
+    }
+
+    export function hasDotDotDotToken(node: Node) {
+        return node && node.kind === SyntaxKind.Parameter && (<ParameterDeclaration>node).dotDotDotToken !== undefined;
+    }
+
+    export function hasQuestionToken(node: Node) {
+        if (node) {
+            switch (node.kind) {
+                case SyntaxKind.Parameter:
+                    return (<ParameterDeclaration>node).questionToken !== undefined;
+                case SyntaxKind.Method:
+                    return (<MethodDeclaration>node).questionToken !== undefined;
+                case SyntaxKind.ShorthandPropertyAssignment:
+                case SyntaxKind.PropertyAssignment:
+                case SyntaxKind.Property:
+                    return (<PropertyDeclaration>node).questionToken !== undefined;
+            }
+        }
+
+        return false;
+    }
+
+    export function hasRestParameters(s: SignatureDeclaration): boolean {
+        return s.parameters.length > 0 && s.parameters[s.parameters.length - 1].dotDotDotToken !== undefined;
+    }
+
+    export function isLiteralKind(kind: SyntaxKind): boolean {
+        return SyntaxKind.FirstLiteralToken <= kind && kind <= SyntaxKind.LastLiteralToken;
+    }
+
+    export function isTextualLiteralKind(kind: SyntaxKind): boolean {
+        return kind === SyntaxKind.StringLiteral || kind === SyntaxKind.NoSubstitutionTemplateLiteral;
+    }
+
+    export function isTemplateLiteralKind(kind: SyntaxKind): boolean {
+        return SyntaxKind.FirstTemplateToken <= kind && kind <= SyntaxKind.LastTemplateToken;
+    }
+
+    export function isInAmbientContext(node: Node): boolean {
+        while (node) {
+            if (node.flags & (NodeFlags.Ambient | NodeFlags.DeclarationFile)) return true;
+            node = node.parent;
+        }
+        return false;
+    }
+
+    export function isDeclaration(node: Node): boolean {
+        switch (node.kind) {
+            case SyntaxKind.TypeParameter:
+            case SyntaxKind.Parameter:
+            case SyntaxKind.VariableDeclaration:
+            case SyntaxKind.Property:
+            case SyntaxKind.PropertyAssignment:
+            case SyntaxKind.ShorthandPropertyAssignment:
+            case SyntaxKind.EnumMember:
+            case SyntaxKind.Method:
+            case SyntaxKind.FunctionDeclaration:
+            case SyntaxKind.GetAccessor:
+            case SyntaxKind.SetAccessor:
+            case SyntaxKind.Constructor:
+            case SyntaxKind.ClassDeclaration:
+            case SyntaxKind.InterfaceDeclaration:
+            case SyntaxKind.TypeAliasDeclaration:
+            case SyntaxKind.EnumDeclaration:
+            case SyntaxKind.ModuleDeclaration:
+            case SyntaxKind.ImportDeclaration:
+                return true;
+        }
+        return false;
+    }
+
+    export function isStatement(n: Node): boolean {
+        switch (n.kind) {
+            case SyntaxKind.BreakStatement:
+            case SyntaxKind.ContinueStatement:
+            case SyntaxKind.DebuggerStatement:
+            case SyntaxKind.DoStatement:
+            case SyntaxKind.ExpressionStatement:
+            case SyntaxKind.EmptyStatement:
+            case SyntaxKind.ForInStatement:
+            case SyntaxKind.ForStatement:
+            case SyntaxKind.IfStatement:
+            case SyntaxKind.LabeledStatement:
+            case SyntaxKind.ReturnStatement:
+            case SyntaxKind.SwitchStatement:
+            case SyntaxKind.ThrowKeyword:
+            case SyntaxKind.TryStatement:
+            case SyntaxKind.VariableStatement:
+            case SyntaxKind.WhileStatement:
+            case SyntaxKind.WithStatement:
+            case SyntaxKind.ExportAssignment:
+                return true;
+            default:
+                return false;
+        }
+    }
+
+    // True if the given identifier, string literal, or number literal is the name of a declaration node
+    export function isDeclarationOrFunctionExpressionOrCatchVariableName(name: Node): boolean {
+        if (name.kind !== SyntaxKind.Identifier && name.kind !== SyntaxKind.StringLiteral && name.kind !== SyntaxKind.NumericLiteral) {
+            return false;
+        }
+
+        var parent = name.parent;
+        if (isDeclaration(parent) || parent.kind === SyntaxKind.FunctionExpression) {
+            return (<Declaration>parent).name === name;
+        }
+
+        if (parent.kind === SyntaxKind.CatchClause) {
+            return (<CatchClause>parent).name === name;
+        }
+
+        return false;
+    }
+
+    export function getClassBaseTypeNode(node: ClassDeclaration) {
+        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
+        return heritageClause && heritageClause.types.length > 0 ? heritageClause.types[0] : undefined;
+    }
+
+    export function getClassImplementedTypeNodes(node: ClassDeclaration) {
+        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ImplementsKeyword);
+        return heritageClause ? heritageClause.types : undefined;
+    }
+
+    export function getInterfaceBaseTypeNodes(node: InterfaceDeclaration) {
+        var heritageClause = getHeritageClause(node.heritageClauses, SyntaxKind.ExtendsKeyword);
+        return heritageClause ? heritageClause.types : undefined;
+    }
+
+    export function getHeritageClause(clauses: NodeArray<HeritageClause>, kind: SyntaxKind) {
+        if (clauses) {
+            for (var i = 0, n = clauses.length; i < n; i++) {
+                if (clauses[i].token === kind) {
+                    return clauses[i];
+                }
+            }
+        }
+
+        return undefined;
+    }
+
+    export function tryResolveScriptReference(program: Program, sourceFile: SourceFile, reference: FileReference) {
+        if (!program.getCompilerOptions().noResolve) {
+            var referenceFileName = isRootedDiskPath(reference.filename) ? reference.filename : combinePaths(getDirectoryPath(sourceFile.filename), reference.filename);
+            referenceFileName = getNormalizedAbsolutePath(referenceFileName, program.getCompilerHost().getCurrentDirectory());
+            return program.getSourceFile(referenceFileName);
+        }
+    }
+
+    export function getAncestor(node: Node, kind: SyntaxKind): Node {
+        switch (kind) {
+            // special-cases that can be come first
+            case SyntaxKind.ClassDeclaration:
+                while (node) {
+                    switch (node.kind) {
+                        case SyntaxKind.ClassDeclaration:
+                            return <ClassDeclaration>node;
+                        case SyntaxKind.EnumDeclaration:
+                        case SyntaxKind.InterfaceDeclaration:
+                        case SyntaxKind.TypeAliasDeclaration:
+                        case SyntaxKind.ModuleDeclaration:
+                        case SyntaxKind.ImportDeclaration:
+                            // early exit cases - declarations cannot be nested in classes
+                            return undefined;
+                        default:
+                            node = node.parent;
+                            continue;
+                    }
+                }
+                break;
+            default:
+                while (node) {
+                    if (node.kind === kind) {
+                        return node;
+                    }
+                    node = node.parent;
+                }
+                break;
+        }
+
+        return undefined;
+    }
+
+    export function getFileReferenceFromReferencePath(comment: string, commentRange: CommentRange): ReferencePathMatchResult {
+        var simpleReferenceRegEx = /^\/\/\/\s*<reference\s+/gim;
+        var isNoDefaultLibRegEx = /^(\/\/\/\s*<reference\s+no-default-lib\s*=\s*)('|")(.+?)\2\s*\/>/gim;
+        if (simpleReferenceRegEx.exec(comment)) {
+            if (isNoDefaultLibRegEx.exec(comment)) {
+                return {
+                    isNoDefaultLib: true
+                }
+            }
+            else {
+                var matchResult = fullTripleSlashReferencePathRegEx.exec(comment);
+                if (matchResult) {
+                    var start = commentRange.pos;
+                    var end = commentRange.end;
+                    return {
+                        fileReference: {
+                            pos: start,
+                            end: end,
+                            filename: matchResult[3]
+                        },
+                        isNoDefaultLib: false
+                    };
+                }
+                else {
+                    return {
+                        diagnosticMessage: Diagnostics.Invalid_reference_directive_syntax,
+                        isNoDefaultLib: false
+                    };
+                }
+            }
+        }
+        return undefined;
+    }
+
+    export function isKeyword(token: SyntaxKind): boolean {
+        return SyntaxKind.FirstKeyword <= token && token <= SyntaxKind.LastKeyword;
+    }
+
+    export function isTrivia(token: SyntaxKind) {
+        return SyntaxKind.FirstTriviaToken <= token && token <= SyntaxKind.LastTriviaToken;
+    }
+
+    export function isModifier(token: SyntaxKind): boolean {
+        switch (token) {
+            case SyntaxKind.PublicKeyword:
+            case SyntaxKind.PrivateKeyword:
+            case SyntaxKind.ProtectedKeyword:
+            case SyntaxKind.StaticKeyword:
+            case SyntaxKind.ExportKeyword:
+            case SyntaxKind.DeclareKeyword:
+            case SyntaxKind.ConstKeyword:
+                return true;
+        }
+        return false;
+    }
+
+}
\ No newline at end of file
diff --git a/src/harness/fourslash.ts b/src/harness/fourslash.ts
index b48f8fba5f6..e253f7b575b 100644
--- a/src/harness/fourslash.ts
+++ b/src/harness/fourslash.ts
@@ -364,7 +364,7 @@ module FourSlash {
             this.formatCodeOptions = {
                 IndentSize: 4,
                 TabSize: 4,
-                NewLineCharacter: sys.newLine,
+                NewLineCharacter: ts.sys.newLine,
                 ConvertTabsToSpaces: true,
                 InsertSpaceAfterCommaDelimiter: true,
                 InsertSpaceAfterSemicolonInForStatements: true,
@@ -751,11 +751,11 @@ module FourSlash {
         }
 
         private getMemberListAtCaret() {
-            return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, true);
+            return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition);
         }
 
         private getCompletionListAtCaret() {
-            return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition, false);
+            return this.languageService.getCompletionsAtPosition(this.activeFile.fileName, this.currentCaretPosition);
         }
 
         private getCompletionEntryDetails(entryName: string) {
@@ -1365,7 +1365,7 @@ module FourSlash {
                     this.languageService.getSignatureHelpItems(this.activeFile.fileName, offset);
                 } else if (prevChar === ' ' && /A-Za-z_/.test(ch)) {
                     /* Completions */
-                    this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset, false);
+                    this.languageService.getCompletionsAtPosition(this.activeFile.fileName, offset);
                 }
 
                 if (i % errorCadence === 0) {
@@ -1748,9 +1748,9 @@ module FourSlash {
             }
 
             function jsonMismatchString() {
-                return sys.newLine +
-                    "expected: '" + sys.newLine + JSON.stringify(expected, (k,v) => v, 2) + "'" + sys.newLine +
-                    "actual:   '" + sys.newLine + JSON.stringify(actual, (k, v) => v, 2) + "'";
+                return ts.sys.newLine +
+                    "expected: '" + ts.sys.newLine + JSON.stringify(expected, (k,v) => v, 2) + "'" + ts.sys.newLine +
+                    "actual:   '" + ts.sys.newLine + JSON.stringify(actual, (k, v) => v, 2) + "'";
             }
         }
 
@@ -2247,9 +2247,9 @@ module FourSlash {
             { unitName: fileName, content: content }],
             (fn, contents) => result = contents,
             ts.ScriptTarget.Latest,
-            sys.useCaseSensitiveFileNames);
+            ts.sys.useCaseSensitiveFileNames);
         // TODO (drosen): We need to enforce checking on these tests.
-        var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true }, host);
+        var program = ts.createProgram([Harness.Compiler.fourslashFilename, fileName], { out: "fourslashTestOutput.js", noResolve: true, target: ts.ScriptTarget.ES3 }, host);
         var checker = ts.createTypeChecker(program, /*fullTypeCheckMode*/ true);
 
         var errors = program.getDiagnostics().concat(checker.getDiagnostics());
diff --git a/src/harness/harness.ts b/src/harness/harness.ts
index c0d3ddedce3..c56b29ed3b8 100644
--- a/src/harness/harness.ts
+++ b/src/harness/harness.ts
@@ -22,10 +22,13 @@
 /// <reference path='external\chai.d.ts'/>
 /// <reference path='sourceMapRecorder.ts'/>
 
+declare var require: any;
+declare var process: any;
+
 // this will work in the browser via browserify
 var _chai: typeof chai = require('chai');
 var assert: typeof _chai.assert = _chai.assert;
-declare var __dirname: any; // Node-specific
+declare var __dirname: string; // Node-specific
 var global = <any>Function("return this").call(null);
 
 module Utils {
@@ -41,7 +44,7 @@ module Utils {
     export function getExecutionEnvironment() {
         if (typeof WScript !== "undefined" && typeof ActiveXObject === "function") {
             return ExecutionEnvironment.CScript;
-        } else if (process && (<any>process).execPath && (<any>process).execPath.indexOf("node") !== -1) {
+        } else if (process && process.execPath && process.execPath.indexOf("node") !== -1) {
             return ExecutionEnvironment.Node;
         } else {
             return ExecutionEnvironment.Browser;
@@ -89,7 +92,7 @@ module Utils {
         }
 
         try {
-            var content = sys.readFile(Harness.userSpecifiedroot + path);
+            var content = ts.sys.readFile(Harness.userSpecifiedroot + path);
         }
         catch (err) {
             return undefined;
@@ -156,8 +159,8 @@ module Harness {
                 fso = {};
             }
 
-            export var readFile: typeof IO.readFile = sys.readFile;
-            export var writeFile: typeof IO.writeFile = sys.writeFile;
+            export var readFile: typeof IO.readFile = ts.sys.readFile;
+            export var writeFile: typeof IO.writeFile = ts.sys.writeFile;
             export var directoryName: typeof IO.directoryName = fso.GetParentFolderName;
             export var directoryExists: typeof IO.directoryExists = fso.FolderExists;
             export var fileExists: typeof IO.fileExists = fso.FileExists;
@@ -218,8 +221,8 @@ module Harness {
                 fs = pathModule = {};
             }
 
-            export var readFile: typeof IO.readFile = sys.readFile;
-            export var writeFile: typeof IO.writeFile = sys.writeFile;
+            export var readFile: typeof IO.readFile = ts.sys.readFile;
+            export var writeFile: typeof IO.writeFile = ts.sys.writeFile;
             export var fileExists: typeof IO.fileExists = fs.existsSync;
             export var log: typeof IO.log = console.log;
 
@@ -547,7 +550,7 @@ module Harness {
         export var fourslashSourceFile: ts.SourceFile;
 
         export function getCanonicalFileName(fileName: string): string {
-            return sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
+            return ts.sys.useCaseSensitiveFileNames ? fileName : fileName.toLowerCase();
         }
 
         export function createCompilerHost(inputFiles: { unitName: string; content: string; }[],
@@ -571,8 +574,7 @@ module Harness {
             inputFiles.forEach(register);
 
             return {
-                getCurrentDirectory: sys.getCurrentDirectory,
-                getCancellationToken: (): any => undefined,
+                getCurrentDirectory: ts.sys.getCurrentDirectory,
                 getSourceFile: (fn, languageVersion) => {
                     if (Object.prototype.hasOwnProperty.call(filemap, getCanonicalFileName(fn))) {
                         return filemap[getCanonicalFileName(fn)];
@@ -594,7 +596,7 @@ module Harness {
                 writeFile,
                 getCanonicalFileName,
                 useCaseSensitiveFileNames: () => useCaseSensitiveFileNames,
-                getNewLine: ()=> sys.newLine
+                getNewLine: ()=> ts.sys.newLine
             };
         }
 
@@ -664,7 +666,7 @@ module Harness {
                     settingsCallback(null);
                 }
 
-                var useCaseSensitiveFileNames = sys.useCaseSensitiveFileNames;
+                var useCaseSensitiveFileNames = ts.sys.useCaseSensitiveFileNames;
                 this.settings.forEach(setting => {
                     switch (setting.flag.toLowerCase()) {
                         // "filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noimplicitany", "noresolve"
@@ -742,7 +744,7 @@ module Harness {
 
                         case 'newline':
                         case 'newlines':
-                            sys.newLine = setting.value;
+                            ts.sys.newLine = setting.value;
                             break;
 
                         case 'comments':
@@ -774,9 +776,19 @@ module Harness {
                         case 'errortruncation':
                             options.noErrorTruncation = setting.value === 'false';
                             break;
+
                         case 'preserveconstenums':
                             options.preserveConstEnums = setting.value === 'true';
                             break;
+
+                        case 'suppressimplicitanyindexerrors':
+                            options.suppressImplicitAnyIndexErrors = setting.value === 'true';
+                            break;
+
+                        case 'includebuiltfile':
+                            inputFiles.push({ unitName: setting.value, content: IO.readFile(libFolder + setting.value)});
+                            break;
+
                         default:
                             throw new Error('Unsupported compiler setting ' + setting.flag);
                     }
@@ -817,11 +829,11 @@ module Harness {
                 });
                 this.lastErrors = errors;
 
-                var result = new CompilerResult(fileOutputs, errors, program, sys.getCurrentDirectory(), emitResult ? emitResult.sourceMaps : undefined);
+                var result = new CompilerResult(fileOutputs, errors, program, ts.sys.getCurrentDirectory(), emitResult ? emitResult.sourceMaps : undefined);
                 onComplete(result, checker);
 
                 // reset what newline means in case the last test changed it
-                sys.newLine = '\r\n';
+                ts.sys.newLine = '\r\n';
                 return options;
             }
 
@@ -916,7 +928,7 @@ module Harness {
                     errorOutput += diagnotic.filename + "(" + diagnotic.line + "," + diagnotic.character + "): ";
                 }
 
-                errorOutput += diagnotic.category + " TS" + diagnotic.code + ": " + diagnotic.message + sys.newLine;
+                errorOutput += diagnotic.category + " TS" + diagnotic.code + ": " + diagnotic.message + ts.sys.newLine;
             });
 
             return errorOutput;
@@ -1014,7 +1026,7 @@ module Harness {
             assert.equal(totalErrorsReported + numLibraryDiagnostics, diagnostics.length, 'total number of errors');
 
             return minimalDiagnosticsToString(diagnostics) +
-                sys.newLine + sys.newLine + outputLines.join('\r\n');
+                ts.sys.newLine + ts.sys.newLine + outputLines.join('\r\n');
         }
 
         export function collateOutputs(outputFiles: Harness.Compiler.GeneratedFile[], clean?: (s: string) => string) {
@@ -1162,7 +1174,8 @@ module Harness {
         var optionRegex = /^[\/]{2}\s*@(\w+)\s*:\s*(\S*)/gm;  // multiple matches on multiple lines
 
         // List of allowed metadata names
-        var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror","noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums"];
+
+        var fileMetadataNames = ["filename", "comments", "declaration", "module", "nolib", "sourcemap", "target", "out", "outdir", "noemitonerror", "noimplicitany", "noresolve", "newline", "newlines", "emitbom", "errortruncation", "usecasesensitivefilenames", "preserveconstenums", "includebuiltfile", "suppressimplicitanyindexerrors"];
 
         function extractCompilerSettings(content: string): CompilerSetting[] {
 
diff --git a/src/harness/harnessLanguageService.ts b/src/harness/harnessLanguageService.ts
index 56fdd0404cd..e4592b7fdec 100644
--- a/src/harness/harnessLanguageService.ts
+++ b/src/harness/harnessLanguageService.ts
@@ -139,6 +139,9 @@ module Harness.LanguageService {
         constructor(private cancellationToken: ts.CancellationToken = CancellationToken.None) {
         }
 
+        public trace(s: string) {
+        }
+
         public addDefaultLibrary() {
             this.addScript(Harness.Compiler.defaultLibFileName, Harness.Compiler.defaultLibSourceFile.text);
         }
diff --git a/src/harness/loggedIO.ts b/src/harness/loggedIO.ts
index c6305c50c10..c6d15c34a84 100644
--- a/src/harness/loggedIO.ts
+++ b/src/harness/loggedIO.ts
@@ -91,7 +91,7 @@ module Playback {
         return run;
     }
 
-    export interface PlaybackSystem extends System, PlaybackControl { }
+    export interface PlaybackSystem extends ts.System, PlaybackControl { }
 
     function createEmptyLog(): IOLog {
         return {
@@ -221,7 +221,7 @@ module Playback {
         //console.log("Swallowed write operation during replay: " + name);
     }
 
-    export function wrapSystem(underlying: System): PlaybackSystem {
+    export function wrapSystem(underlying: ts.System): PlaybackSystem {
         var wrapper: PlaybackSystem = <any>{};
         initWrapper(wrapper, underlying);
 
diff --git a/src/harness/projectsRunner.ts b/src/harness/projectsRunner.ts
index f46f9ae3698..9e2432c1da4 100644
--- a/src/harness/projectsRunner.ts
+++ b/src/harness/projectsRunner.ts
@@ -60,7 +60,7 @@ class ProjectRunner extends RunnerBase {
         var testCase: ProjectRunnerTestCase;
 
         try {
-            var testFileText = sys.readFile(testCaseFileName);
+            var testFileText = ts.sys.readFile(testCaseFileName);
         }
         catch (e) {
             assert(false, "Unable to open testcase file: " + testCaseFileName + ": " + e.message);
@@ -96,7 +96,7 @@ class ProjectRunner extends RunnerBase {
         }
 
         function cleanProjectUrl(url: string) {
-            var diskProjectPath = ts.normalizeSlashes(sys.resolvePath(testCase.projectRoot));
+            var diskProjectPath = ts.normalizeSlashes(ts.sys.resolvePath(testCase.projectRoot));
             var projectRootUrl = "file:///" + diskProjectPath;
             var normalizedProjectRoot = ts.normalizeSlashes(testCase.projectRoot);
             diskProjectPath = diskProjectPath.substr(0, diskProjectPath.lastIndexOf(normalizedProjectRoot));
@@ -119,7 +119,7 @@ class ProjectRunner extends RunnerBase {
         }
 
         function getCurrentDirectory() {
-            return sys.resolvePath(testCase.projectRoot);
+            return ts.sys.resolvePath(testCase.projectRoot);
         }
 
         function compileProjectFiles(moduleKind: ts.ModuleKind, getInputFiles: ()=> string[],
@@ -161,8 +161,8 @@ class ProjectRunner extends RunnerBase {
                     sourceMap: !!testCase.sourceMap,
                     out: testCase.out,
                     outDir: testCase.outDir,
-                    mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? sys.resolvePath(testCase.mapRoot) : testCase.mapRoot,
-                    sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? sys.resolvePath(testCase.sourceRoot) : testCase.sourceRoot,
+                    mapRoot: testCase.resolveMapRoot && testCase.mapRoot ? ts.sys.resolvePath(testCase.mapRoot) : testCase.mapRoot,
+                    sourceRoot: testCase.resolveSourceRoot && testCase.sourceRoot ? ts.sys.resolvePath(testCase.sourceRoot) : testCase.sourceRoot,
                     module: moduleKind,
                     noResolve: testCase.noResolve
                 };
@@ -190,8 +190,8 @@ class ProjectRunner extends RunnerBase {
                     writeFile,
                     getCurrentDirectory,
                     getCanonicalFileName: Harness.Compiler.getCanonicalFileName,
-                    useCaseSensitiveFileNames: () => sys.useCaseSensitiveFileNames,
-                    getNewLine: () => sys.newLine
+                    useCaseSensitiveFileNames: () => ts.sys.useCaseSensitiveFileNames,
+                    getNewLine: () => ts.sys.newLine
                 };
             }
         }
@@ -213,7 +213,7 @@ class ProjectRunner extends RunnerBase {
 
             function getSourceFileText(filename: string): string {
                 try {
-                    var text = sys.readFile(ts.isRootedDiskPath(filename)
+                    var text = ts.sys.readFile(ts.isRootedDiskPath(filename)
                         ? filename
                         : ts.normalizeSlashes(testCase.projectRoot) + "/" + ts.normalizeSlashes(filename));
                 }
@@ -260,14 +260,14 @@ class ProjectRunner extends RunnerBase {
                 // Actual writing of file as in tc.ts
                 function ensureDirectoryStructure(directoryname: string) {
                     if (directoryname) {
-                        if (!sys.directoryExists(directoryname)) {
+                        if (!ts.sys.directoryExists(directoryname)) {
                             ensureDirectoryStructure(ts.getDirectoryPath(directoryname));
-                            sys.createDirectory(directoryname);
+                            ts.sys.createDirectory(directoryname);
                         }
                     }
                 }
                 ensureDirectoryStructure(ts.getDirectoryPath(ts.normalizePath(outputFilePath)));
-                sys.writeFile(outputFilePath, data, writeByteOrderMark);
+                ts.sys.writeFile(outputFilePath, data, writeByteOrderMark);
 
                 outputFiles.push({ emittedFileName: filename, code: data, fileName: diskRelativeName, writeByteOrderMark: writeByteOrderMark });
             }
@@ -374,7 +374,7 @@ class ProjectRunner extends RunnerBase {
                         it('Baseline of emitted result (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, () => {
                             Harness.Baseline.runBaseline('Baseline of emitted result (' + moduleNameToString(compilerResult.moduleKind) + '): ' + testCaseFileName, getBaselineFolder(compilerResult.moduleKind) + outputFile.fileName, () => {
                                 try {
-                                    return sys.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind));
+                                    return ts.sys.readFile(getProjectOutputFolder(outputFile.fileName, compilerResult.moduleKind));
                                 }
                                 catch (e) {
                                     return undefined;
diff --git a/src/harness/runner.ts b/src/harness/runner.ts
index da37c02e224..24349ada3fd 100644
--- a/src/harness/runner.ts
+++ b/src/harness/runner.ts
@@ -94,6 +94,6 @@ if (runners.length === 0) {
     //runners.push(new GeneratedFourslashRunner());
 }
 
-sys.newLine = '\r\n';
+ts.sys.newLine = '\r\n';
 
 runTests(runners);
diff --git a/src/harness/rwcRunner.ts b/src/harness/rwcRunner.ts
index b8bc2a80a52..8d22b1da1d8 100644
--- a/src/harness/rwcRunner.ts
+++ b/src/harness/rwcRunner.ts
@@ -6,17 +6,17 @@
 
 module RWC {
     function runWithIOLog(ioLog: IOLog, fn: () => void) {
-        var oldSys = sys;
+        var oldSys = ts.sys;
 
-        var wrappedSys = Playback.wrapSystem(sys);
+        var wrappedSys = Playback.wrapSystem(ts.sys);
         wrappedSys.startReplayFromData(ioLog);
-        sys = wrappedSys;
+        ts.sys = wrappedSys;
 
         try {
             fn();
         } finally {
             wrappedSys.endReplay();
-            sys = oldSys;
+            ts.sys = oldSys;
         }
     }
 
@@ -74,7 +74,7 @@ module RWC {
                     }
 
                     ts.forEach(ioLog.filesRead, fileRead => {
-                        var resolvedPath = ts.normalizeSlashes(sys.resolvePath(fileRead.path));
+                        var resolvedPath = ts.normalizeSlashes(ts.sys.resolvePath(fileRead.path));
                         var inInputList = ts.forEach(inputFiles, inputFile=> inputFile.unitName === resolvedPath);
                         if (!inInputList) {
                             // Add the file to other files
@@ -92,9 +92,9 @@ module RWC {
                 });
 
                 function getHarnessCompilerInputUnit(fileName: string) {
-                    var unitName = ts.normalizeSlashes(sys.resolvePath(fileName));
+                    var unitName = ts.normalizeSlashes(ts.sys.resolvePath(fileName));
                     try {
-                        var content = sys.readFile(unitName);
+                        var content = ts.sys.readFile(unitName);
                     }
                     catch (e) {
                         // Leave content undefined.
@@ -160,7 +160,7 @@ module RWC {
                         }
 
                         return Harness.Compiler.minimalDiagnosticsToString(declFileCompilationResult.declResult.errors) +
-                            sys.newLine + sys.newLine +
+                            ts.sys.newLine + ts.sys.newLine +
                             Harness.Compiler.getErrorBaseline(declFileCompilationResult.declInputFiles.concat(declFileCompilationResult.declOtherFiles), declFileCompilationResult.declResult.errors);
                     }, false, baselineOpts);
                 }
diff --git a/src/services/findReferenceHelpers.ts b/src/services/findReferenceHelpers.ts
deleted file mode 100644
index 68131a41115..00000000000
--- a/src/services/findReferenceHelpers.ts
+++ /dev/null
@@ -1,152 +0,0 @@
-// Copyright (c) Microsoft. All rights reserved. Licensed under the Apache License, Version 2.0. 
-// See LICENSE.txt in the project root for complete license information.
-
-///<reference path='references.ts' />
-
-module TypeScript.Services {
-    export class FindReferenceHelpers {
-        public static compareSymbolsForLexicalIdentity(firstSymbol: TypeScript.PullSymbol, secondSymbol: TypeScript.PullSymbol): boolean {
-            // Unwrap modules so that we're always referring to the variable.
-            if (!firstSymbol.isAlias() && firstSymbol.isContainer()) {
-                var containerForFirstSymbol = (<TypeScript.PullContainerSymbol>firstSymbol);
-                if (containerForFirstSymbol.getInstanceSymbol()) {
-                    firstSymbol = containerForFirstSymbol.getInstanceSymbol();
-                }
-            }
-
-            if (!secondSymbol.isAlias() && secondSymbol.isContainer()) {
-                var containerForSecondSymbol = (<TypeScript.PullContainerSymbol>secondSymbol);
-                if (containerForSecondSymbol.getInstanceSymbol()) {
-                    secondSymbol = containerForSecondSymbol.getInstanceSymbol();
-                }
-            }
-
-            if (firstSymbol.kind === secondSymbol.kind) {
-                if (firstSymbol === secondSymbol) {
-                    return true;
-                }
-
-                // If we have two variables and they have the same name and the same parent, then 
-                // they are the same symbol.
-                if (firstSymbol.kind === TypeScript.PullElementKind.Variable &&
-                    firstSymbol.name === secondSymbol.name &&
-                    firstSymbol.getDeclarations() && firstSymbol.getDeclarations().length >= 1 &&
-                    secondSymbol.getDeclarations() && secondSymbol.getDeclarations().length >= 1) {
-
-                    var firstSymbolDecl = firstSymbol.getDeclarations()[0];
-                    var secondSymbolDecl = secondSymbol.getDeclarations()[0];
-
-                    return firstSymbolDecl.getParentDecl() === secondSymbolDecl.getParentDecl();
-                }
-
-                // If we have two properties that belong to an object literal, then we need ot see
-                // if they came from teh same object literal ast.
-                if (firstSymbol.kind === TypeScript.PullElementKind.Property &&
-                    firstSymbol.name === secondSymbol.name &&
-                    firstSymbol.getDeclarations() && firstSymbol.getDeclarations().length >= 1 &&
-                    secondSymbol.getDeclarations() && secondSymbol.getDeclarations().length >= 1) {
-
-                    var firstSymbolDecl = firstSymbol.getDeclarations()[0];
-                    var secondSymbolDecl = secondSymbol.getDeclarations()[0];
-
-                    var firstParentDecl = firstSymbolDecl.getParentDecl();
-                    var secondParentDecl = secondSymbolDecl.getParentDecl();
-
-                    if (firstParentDecl.kind === TypeScript.PullElementKind.ObjectLiteral &&
-                        secondParentDecl.kind === TypeScript.PullElementKind.ObjectLiteral) {
-
-                        return firstParentDecl.ast() === secondParentDecl.ast();
-                    }
-                }
-
-                // check if we are dealing with the implementation of interface method or a method override
-                if (firstSymbol.name === secondSymbol.name) {
-                    // at this point firstSymbol.kind === secondSymbol.kind so we can pick any of those
-                    switch (firstSymbol.kind) {
-                        case PullElementKind.Property:
-                        case PullElementKind.Method:
-                        case PullElementKind.GetAccessor:
-                        case PullElementKind.SetAccessor:
-                            // these kinds can only be defined in types
-                            var t1 = <PullTypeSymbol>firstSymbol.getContainer();
-                            var t2 = <PullTypeSymbol>secondSymbol.getContainer();
-                            t1._resolveDeclaredSymbol();
-                            t2._resolveDeclaredSymbol();
-
-                            return t1.hasBase(t2) || t2.hasBase(t1);
-                            break;
-                    }
-                }
-
-                return false;
-            }
-            else {
-                switch (firstSymbol.kind) {
-                    case TypeScript.PullElementKind.Class: {
-                        return this.checkSymbolsForDeclarationEquality(firstSymbol, secondSymbol);
-                    }
-                    case TypeScript.PullElementKind.Property: {
-                        if (firstSymbol.isAccessor()) {
-                            var getterSymbol = (<TypeScript.PullAccessorSymbol>firstSymbol).getGetter();
-                            var setterSymbol = (<TypeScript.PullAccessorSymbol>firstSymbol).getSetter();
-
-                            if (getterSymbol && getterSymbol === secondSymbol) {
-                                return true;
-                            }
-
-                            if (setterSymbol && setterSymbol === secondSymbol) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    }
-                    case TypeScript.PullElementKind.Function: {
-                        if (secondSymbol.isAccessor()) {
-                            var getterSymbol = (<TypeScript.PullAccessorSymbol>secondSymbol).getGetter();
-                            var setterSymbol = (<TypeScript.PullAccessorSymbol>secondSymbol).getSetter();
-
-                            if (getterSymbol && getterSymbol === firstSymbol) {
-                                return true;
-                            }
-
-                            if (setterSymbol && setterSymbol === firstSymbol) {
-                                return true;
-                            }
-                        }
-                        return false;
-                    }
-                    case TypeScript.PullElementKind.ConstructorMethod: {
-                        return this.checkSymbolsForDeclarationEquality(firstSymbol, secondSymbol);
-                    }
-                }
-            }
-
-            return firstSymbol === secondSymbol;
-        }
-
-        private static checkSymbolsForDeclarationEquality(firstSymbol: TypeScript.PullSymbol, secondSymbol: TypeScript.PullSymbol): boolean {
-            var firstSymbolDeclarations: TypeScript.PullDecl[] = firstSymbol.getDeclarations();
-            var secondSymbolDeclarations: TypeScript.PullDecl[] = secondSymbol.getDeclarations();
-            for (var i = 0, iLen = firstSymbolDeclarations.length; i < iLen; i++) {
-                for (var j = 0, jLen = secondSymbolDeclarations.length; j < jLen; j++) {
-                    if (this.declarationsAreSameOrParents(firstSymbolDeclarations[i], secondSymbolDeclarations[j])) {
-                        return true;
-                    }
-                }
-            }
-            return false;
-        }
-
-        private static declarationsAreSameOrParents(firstDecl: TypeScript.PullDecl, secondDecl: TypeScript.PullDecl): boolean {
-            var firstParent: TypeScript.PullDecl = firstDecl.getParentDecl();
-            var secondParent: TypeScript.PullDecl = secondDecl.getParentDecl();
-            if (firstDecl === secondDecl ||
-                firstDecl === secondParent ||
-                firstParent === secondDecl ||
-                firstParent === secondParent) {
-                return true;
-            }
-            return false;
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/services/formatting.ts b/src/services/formatting/formatting.ts
similarity index 93%
rename from src/services/formatting.ts
rename to src/services/formatting/formatting.ts
index ad18df41317..22f90a0cdee 100644
--- a/src/services/formatting.ts
+++ b/src/services/formatting/formatting.ts
@@ -1,7 +1,7 @@
-///<reference path='services.ts' />
-///<reference path='formatting\indentation.ts' />
-///<reference path='formatting\formattingScanner.ts' />
-///<reference path='formatting\rulesProvider.ts' />
+///<reference path='..\services.ts' />
+///<reference path='formattingScanner.ts' />
+///<reference path='rulesProvider.ts' />
+///<reference path='references.ts' />
 
 module ts.formatting {
 
@@ -983,4 +983,56 @@ module ts.formatting {
 
         return SyntaxKind.Unknown;
     }
+
+    var internedTabsIndentation: string[];
+    var internedSpacesIndentation: string[];
+
+    export function getIndentationString(indentation: number, options: FormatCodeOptions): string {
+        if (!options.ConvertTabsToSpaces) {
+            var tabs = Math.floor(indentation / options.TabSize);
+            var spaces = indentation - tabs * options.TabSize;
+
+            var tabString: string;
+            if (!internedTabsIndentation) {
+                internedTabsIndentation = [];
+            }
+
+            if (internedTabsIndentation[tabs] === undefined) {
+                internedTabsIndentation[tabs] = tabString = repeat('\t', tabs);
+            }
+            else {
+                tabString = internedTabsIndentation[tabs];
+            }
+
+            return spaces ? tabString + repeat(" ", spaces) : tabString;
+        }
+        else {
+            var spacesString: string;
+            var quotient = Math.floor(indentation / options.IndentSize);
+            var remainder = indentation % options.IndentSize;
+            if (!internedSpacesIndentation) {
+                internedSpacesIndentation = [];
+            }
+
+            if (internedSpacesIndentation[quotient] === undefined) {
+                spacesString = repeat(" ", options.IndentSize * quotient);
+                internedSpacesIndentation[quotient] = spacesString;
+            }
+            else {
+                spacesString = internedSpacesIndentation[quotient];
+            }
+
+
+            return remainder ? spacesString + repeat(" ", remainder) : spacesString;
+        }
+
+        function repeat(value: string, count: number): string {
+            var s = "";
+            for (var i = 0; i < count; ++i) {
+                s += value;
+            }
+
+            return s;
+        }
+    }
 }
\ No newline at end of file
diff --git a/src/services/formatting/formattingScanner.ts b/src/services/formatting/formattingScanner.ts
index 710881bf80b..7ddfecc17f2 100644
--- a/src/services/formatting/formattingScanner.ts
+++ b/src/services/formatting/formattingScanner.ts
@@ -1,4 +1,4 @@
-/// <reference path="..\formatting.ts"/>
+/// <reference path="formatting.ts"/>
 /// <reference path="..\..\compiler\scanner.ts"/>
 
 module ts.formatting {
diff --git a/src/services/formatting/references.ts b/src/services/formatting/references.ts
index 9f4b7e37436..b421424a61b 100644
--- a/src/services/formatting/references.ts
+++ b/src/services/formatting/references.ts
@@ -13,7 +13,6 @@
 // limitations under the License.
 //
 
-///<reference path='..\text.ts' />
 ///<reference path='..\services.ts' />
 ///<reference path='formattingContext.ts' />
 ///<reference path='formattingRequestKind.ts' />
@@ -25,5 +24,4 @@
 ///<reference path='ruleOperationContext.ts' />
 ///<reference path='rules.ts' />
 ///<reference path='rulesMap.ts' />
-///<reference path='tokenRange.ts' />
-///<reference path='tokenSpan.ts' /> 
\ No newline at end of file
+///<reference path='tokenRange.ts' />
\ No newline at end of file
diff --git a/src/services/smartIndenter.ts b/src/services/formatting/smartIndenter.ts
similarity index 97%
rename from src/services/smartIndenter.ts
rename to src/services/formatting/smartIndenter.ts
index e93cb5616a9..8da1ef0c93b 100644
--- a/src/services/smartIndenter.ts
+++ b/src/services/formatting/smartIndenter.ts
@@ -1,4 +1,4 @@
-///<reference path='services.ts' />
+///<reference path='..\services.ts' />
 
 module ts.formatting {
     export module SmartIndenter {
diff --git a/src/services/formatting/tokenSpan.ts b/src/services/formatting/tokenSpan.ts
deleted file mode 100644
index 1d8173a8227..00000000000
--- a/src/services/formatting/tokenSpan.ts
+++ /dev/null
@@ -1,24 +0,0 @@
-//
-// Copyright (c) Microsoft Corporation.  All rights reserved.
-// 
-// Licensed under the Apache License, Version 2.0 (the "License");
-// you may not use this file except in compliance with the License.
-// You may obtain a copy of the License at
-//   http://www.apache.org/licenses/LICENSE-2.0
-//
-// Unless required by applicable law or agreed to in writing, software
-// distributed under the License is distributed on an "AS IS" BASIS,
-// WITHOUT WARRANTIES OR CONDITIONS OF ANY KIND, either express or implied.
-// See the License for the specific language governing permissions and
-// limitations under the License.
-//
-
-///<reference path='references.ts' />
-
-module ts.formatting {
-    export class TokenSpan extends TextSpan {
-        constructor(public kind: SyntaxKind, start: number, length: number) {
-            super(start, length);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/services/outliningElementsCollector.ts b/src/services/outliningElementsCollector.ts
index 83eef2f4378..5af69cd3626 100644
--- a/src/services/outliningElementsCollector.ts
+++ b/src/services/outliningElementsCollector.ts
@@ -14,22 +14,6 @@
 //
 
 module ts {
-
-    export interface OutliningSpan {
-        /** 
-         * @param textSpan The span of the document to actually collapse.
-         * @param hintSpan The span of the document to display when the user hovers over the 
-         *       collapsed span.
-         * @param bannerText The text to display in the editor for the collapsed region.
-         * @param autoCollapse Whether or not this region should be automatically collapsed when 
-         *        the 'Collapse to Definitions' command is invoked.
-         */
-        textSpan: TextSpan;
-        hintSpan: TextSpan;
-        bannerText: string;
-        autoCollapse: boolean;
-    }
-
     export module OutliningElementsCollector {
         export function collectElements(sourceFile: SourceFile): OutliningSpan[] {
             var elements: OutliningSpan[] = [];
diff --git a/src/services/services.ts b/src/services/services.ts
index 980b7ecda3d..665a06ac9b5 100644
--- a/src/services/services.ts
+++ b/src/services/services.ts
@@ -4,16 +4,18 @@
 /// <reference path="..\compiler\parser.ts"/>
 /// <reference path="..\compiler\checker.ts"/>
 
-/// <reference path='text.ts' />
+/// <reference path='breakpoints.ts' />
 /// <reference path='outliningElementsCollector.ts' />
 /// <reference path='navigationBar.ts' />
-/// <reference path='breakpoints.ts' />
 /// <reference path='signatureHelp.ts' />
 /// <reference path='utilities.ts' />
-/// <reference path='smartIndenter.ts' />
-/// <reference path='formatting.ts' />
+/// <reference path='formatting\formatting.ts' />
+/// <reference path='formatting\smartIndenter.ts' />
 
 module ts {
+
+    export var servicesVersion = "0.4"
+
     export interface Node {
         getSourceFile(): SourceFile;
         getChildCount(sourceFile?: SourceFile): number;
@@ -876,8 +878,8 @@ module ts {
         getScriptVersion(fileName: string): string;
         getScriptIsOpen(fileName: string): boolean;
         getScriptSnapshot(fileName: string): IScriptSnapshot;
-        getLocalizedDiagnosticMessages(): any;
-        getCancellationToken(): CancellationToken;
+        getLocalizedDiagnosticMessages?(): any;
+        getCancellationToken?(): CancellationToken;
         getCurrentDirectory(): string;
         getDefaultLibFilename(options: CompilerOptions): string;
     }
@@ -896,7 +898,7 @@ module ts {
         getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
         getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
 
-        getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): CompletionInfo;
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
         getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
 
         getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
@@ -933,6 +935,301 @@ module ts {
         dispose(): void;
     }
 
+    export class TextSpan {
+        private _start: number;
+        private _length: number;
+
+        /**
+            * Creates a TextSpan instance beginning with the position Start and having the Length
+            * specified with length.
+            */
+        constructor(start: number, length: number) {
+            Debug.assert(start >= 0, "start");
+            Debug.assert(length >= 0, "length");
+
+            this._start = start;
+            this._length = length;
+        }
+
+        public toJSON(key: any): any {
+            return { start: this._start, length: this._length };
+        }
+
+        public start(): number {
+            return this._start;
+        }
+
+        public length(): number {
+            return this._length;
+        }
+
+        public end(): number {
+            return this._start + this._length;
+        }
+
+        public isEmpty(): boolean {
+            return this._length === 0;
+        }
+
+        /**
+            * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less 
+            * than End, otherwise false.
+            * @param position The position to check.
+            */
+        public containsPosition(position: number): boolean {
+            return position >= this._start && position < this.end();
+        }
+
+        /**
+            * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.
+            * @param span The span to check.
+            */
+        public containsTextSpan(span: TextSpan): boolean {
+            return span._start >= this._start && span.end() <= this.end();
+        }
+
+        /**
+            * Determines whether the given span overlaps this span. Two spans are considered to overlap 
+            * if they have positions in common and neither is empty. Empty spans do not overlap with any 
+            * other span. Returns true if the spans overlap, false otherwise.
+            * @param span The span to check.
+            */
+        public overlapsWith(span: TextSpan): boolean {
+            var overlapStart = Math.max(this._start, span._start);
+            var overlapEnd = Math.min(this.end(), span.end());
+
+            return overlapStart < overlapEnd;
+        }
+
+        /**
+            * Returns the overlap with the given span, or undefined if there is no overlap.
+            * @param span The span to check.
+            */
+        public overlap(span: TextSpan): TextSpan {
+            var overlapStart = Math.max(this._start, span._start);
+            var overlapEnd = Math.min(this.end(), span.end());
+
+            if (overlapStart < overlapEnd) {
+                return TextSpan.fromBounds(overlapStart, overlapEnd);
+            }
+
+            return undefined;
+        }
+
+        /**
+            * Determines whether span intersects this span. Two spans are considered to 
+            * intersect if they have positions in common or the end of one span 
+            * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.
+            * @param The span to check.
+            */
+        public intersectsWithTextSpan(span: TextSpan): boolean {
+            return span._start <= this.end() && span.end() >= this._start;
+        }
+
+        public intersectsWith(start: number, length: number): boolean {
+            var end = start + length;
+            return start <= this.end() && end >= this._start;
+        }
+
+        /**
+            * Determines whether the given position intersects this span. 
+            * A position is considered to intersect if it is between the start and
+            * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.
+            * @param position The position to check.
+            */
+        public intersectsWithPosition(position: number): boolean {
+            return position <= this.end() && position >= this._start;
+        }
+
+        /**
+            * Returns the intersection with the given span, or undefined if there is no intersection.
+            * @param span The span to check.
+            */
+        public intersection(span: TextSpan): TextSpan {
+            var intersectStart = Math.max(this._start, span._start);
+            var intersectEnd = Math.min(this.end(), span.end());
+
+            if (intersectStart <= intersectEnd) {
+                return TextSpan.fromBounds(intersectStart, intersectEnd);
+            }
+
+            return undefined;
+        }
+
+        /**
+            * Creates a new TextSpan from the given start and end positions
+            * as opposed to a position and length.
+            */
+        public static fromBounds(start: number, end: number): TextSpan {
+            Debug.assert(start >= 0);
+            Debug.assert(end - start >= 0);
+            return new TextSpan(start, end - start);
+        }
+    }
+
+    export class TextChangeRange {
+        public static unchanged = new TextChangeRange(new TextSpan(0, 0), 0);
+
+        private _span: TextSpan;
+        private _newLength: number;
+
+        /**
+            * Initializes a new instance of TextChangeRange.
+            */
+        constructor(span: TextSpan, newLength: number) {
+            Debug.assert(newLength >= 0, "newLength");
+
+            this._span = span;
+            this._newLength = newLength;
+        }
+
+        /**
+            * The span of text before the edit which is being changed
+            */
+        public span(): TextSpan {
+            return this._span;
+        }
+
+        /**
+            * Width of the span after the edit.  A 0 here would represent a delete
+            */
+        public newLength(): number {
+            return this._newLength;
+        }
+
+        public newSpan(): TextSpan {
+            return new TextSpan(this.span().start(), this.newLength());
+        }
+
+        public isUnchanged(): boolean {
+            return this.span().isEmpty() && this.newLength() === 0;
+        }
+
+        /**
+            * Called to merge all the changes that occurred across several versions of a script snapshot 
+            * into a single change.  i.e. if a user keeps making successive edits to a script we will
+            * have a text change from V1 to V2, V2 to V3, ..., Vn.  
+            * 
+            * This function will then merge those changes into a single change range valid between V1 and
+            * Vn.
+            */
+        public static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange {
+            if (changes.length === 0) {
+                return TextChangeRange.unchanged;
+            }
+
+            if (changes.length === 1) {
+                return changes[0];
+            }
+
+            // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }
+            // as it makes things much easier to reason about.
+            var change0 = changes[0];
+
+            var oldStartN = change0.span().start();
+            var oldEndN = change0.span().end();
+            var newEndN = oldStartN + change0.newLength();
+
+            for (var i = 1; i < changes.length; i++) {
+                var nextChange = changes[i];
+
+                // Consider the following case:
+                // i.e. two edits.  The first represents the text change range { { 10, 50 }, 30 }.  i.e. The span starting
+                // at 10, with length 50 is reduced to length 30.  The second represents the text change range { { 30, 30 }, 40 }.
+                // i.e. the span starting at 30 with length 30 is increased to length 40.
+                //
+                //      0         10        20        30        40        50        60        70        80        90        100
+                //      -------------------------------------------------------------------------------------------------------
+                //                |                                                 /                                          
+                //                |                                            /----                                           
+                //  T1            |                                       /----                                                
+                //                |                                  /----                                                     
+                //                |                             /----                                                          
+                //      -------------------------------------------------------------------------------------------------------
+                //                                     |                            \                                          
+                //                                     |                               \                                       
+                //   T2                                |                                 \                                     
+                //                                     |                                   \                                   
+                //                                     |                                      \                                
+                //      -------------------------------------------------------------------------------------------------------
+                //
+                // Merging these turns out to not be too difficult.  First, determining the new start of the change is trivial
+                // it's just the min of the old and new starts.  i.e.:
+                //
+                //      0         10        20        30        40        50        60        70        80        90        100
+                //      ------------------------------------------------------------*------------------------------------------
+                //                |                                                 /                                          
+                //                |                                            /----                                           
+                //  T1            |                                       /----                                                
+                //                |                                  /----                                                     
+                //                |                             /----                                                          
+                //      ----------------------------------------$-------------------$------------------------------------------
+                //                .                    |                            \                                          
+                //                .                    |                               \                                       
+                //   T2           .                    |                                 \                                     
+                //                .                    |                                   \                                   
+                //                .                    |                                      \                                
+                //      ----------------------------------------------------------------------*--------------------------------
+                //
+                // (Note the dots represent the newly inferrred start.
+                // Determining the new and old end is also pretty simple.  Basically it boils down to paying attention to the
+                // absolute positions at the asterixes, and the relative change between the dollar signs. Basically, we see
+                // which if the two $'s precedes the other, and we move that one forward until they line up.  in this case that
+                // means:
+                //
+                //      0         10        20        30        40        50        60        70        80        90        100
+                //      --------------------------------------------------------------------------------*----------------------
+                //                |                                                                     /                      
+                //                |                                                                /----                       
+                //  T1            |                                                           /----                            
+                //                |                                                      /----                                 
+                //                |                                                 /----                                      
+                //      ------------------------------------------------------------$------------------------------------------
+                //                .                    |                            \                                          
+                //                .                    |                               \                                       
+                //   T2           .                    |                                 \                                     
+                //                .                    |                                   \                                   
+                //                .                    |                                      \                                
+                //      ----------------------------------------------------------------------*--------------------------------
+                //
+                // In other words (in this case), we're recognizing that the second edit happened after where the first edit
+                // ended with a delta of 20 characters (60 - 40).  Thus, if we go back in time to where the first edit started
+                // that's the same as if we started at char 80 instead of 60.  
+                //
+                // As it so happens, the same logic applies if the second edit precedes the first edit.  In that case rahter
+                // than pusing the first edit forward to match the second, we'll push the second edit forward to match the
+                // first.
+                //
+                // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange
+                // semantics: { { start: 10, length: 70 }, newLength: 60 }
+                //
+                // The math then works out as follows.
+                // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the 
+                // final result like so:
+                //
+                // {
+                //      oldStart3: Min(oldStart1, oldStart2),
+                //      oldEnd3  : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)),
+                //      newEnd3  : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))
+                // }
+
+                var oldStart1 = oldStartN;
+                var oldEnd1 = oldEndN;
+                var newEnd1 = newEndN;
+
+                var oldStart2 = nextChange.span().start();
+                var oldEnd2 = nextChange.span().end();
+                var newEnd2 = oldStart2 + nextChange.newLength();
+
+                oldStartN = Math.min(oldStart1, oldStart2);
+                oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
+                newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
+            }
+
+            return new TextChangeRange(TextSpan.fromBounds(oldStartN, oldEndN), /*newLength: */newEndN - oldStartN);
+        }
+    }
+ 
     export interface ClassifiedSpan {
         textSpan: TextSpan;
         classificationType: string; // ClassificationTypeNames
@@ -1115,6 +1412,23 @@ module ts {
         documentation: SymbolDisplayPart[];
     }
 
+    export interface OutliningSpan {
+        /** The span of the document to actually collapse. */
+        textSpan: TextSpan;
+
+        /** The span of the document to display when the user hovers over the collapsed span. */
+        hintSpan: TextSpan;
+
+        /** The text to display in the editor for the collapsed region. */
+        bannerText: string;
+
+        /** 
+          * Whether or not this region should be automatically collapsed when 
+          * the 'Collapse to Definitions' command is invoked.
+          */
+        autoCollapse: boolean;
+    }
+
     export interface EmitOutput {
         outputFiles: OutputFile[];
         emitOutputStatus: EmitReturnStatus;
@@ -1332,6 +1646,10 @@ module ts {
         owners: string[];
     }
 
+    export interface DisplayPartsSymbolWriter extends SymbolWriter {
+        displayParts(): SymbolDisplayPart[];
+    }
+
     export function displayPartsToString(displayParts: SymbolDisplayPart[]) {
         if (displayParts) {
             return map(displayParts, displayPart => displayPart.text).join("");
@@ -1340,100 +1658,6 @@ module ts {
         return "";
     }
 
-    export interface DisplayPartsSymbolWriter extends SymbolWriter {
-        displayParts(): SymbolDisplayPart[];
-    }
-
-    var displayPartWriter = getDisplayPartWriter();
-    function getDisplayPartWriter(): DisplayPartsSymbolWriter {
-        var displayParts: SymbolDisplayPart[];
-        var lineStart: boolean;
-        var indent: number;
-
-        resetWriter();
-        return {
-            displayParts: () => displayParts,
-            writeKeyword: text => writeKind(text, SymbolDisplayPartKind.keyword),
-            writeOperator: text => writeKind(text, SymbolDisplayPartKind.operator),
-            writePunctuation: text => writeKind(text, SymbolDisplayPartKind.punctuation),
-            writeSpace: text => writeKind(text, SymbolDisplayPartKind.space),
-            writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral),
-            writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName),
-            writeSymbol,
-            writeLine,
-            increaseIndent: () => { indent++; },
-            decreaseIndent: () => { indent--; },
-            clear: resetWriter,
-            trackSymbol: () => { }
-        };
-
-        function writeIndent() {
-            if (lineStart) {
-                var indentString = getIndentString(indent);
-                if (indentString) {
-                    displayParts.push(displayPart(indentString, SymbolDisplayPartKind.space));
-                }
-                lineStart = false;
-            }
-        }
-
-        function writeKind(text: string, kind: SymbolDisplayPartKind) {
-            writeIndent();
-            displayParts.push(displayPart(text, kind));
-        }
-
-        function writeSymbol(text: string, symbol: Symbol) {
-            writeIndent();
-            displayParts.push(symbolPart(text, symbol));
-        }
-
-        function writeLine() {
-            displayParts.push(lineBreakPart());
-            lineStart = true;
-        }
-
-        function resetWriter() {
-            displayParts = []
-            lineStart = true;
-            indent = 0;
-        }
-    }
-
-    function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
-        return <SymbolDisplayPart> {
-            text: text,
-            kind: SymbolDisplayPartKind[kind]
-        };
-    }
-    
-    export function spacePart() {
-        return displayPart(" ", SymbolDisplayPartKind.space);
-    }
-
-    export function keywordPart(kind: SyntaxKind) {
-        return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword);
-    }
-
-    export function punctuationPart(kind: SyntaxKind) {
-        return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation);
-    }
-
-    export function operatorPart(kind: SyntaxKind) {
-        return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator);
-    }
-
-    export function textPart(text: string) {
-        return displayPart(text, SymbolDisplayPartKind.text);
-    }
-
-    export function lineBreakPart() {
-        return displayPart("\n", SymbolDisplayPartKind.lineBreak);
-    }
-
-    function isFirstDeclarationOfSymbolParameter(symbol: Symbol) {
-        return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter;
-    }
-
     function isLocalVariableOrFunction(symbol: Symbol) {
         if (symbol.parent) {
             return false; // This is exported symbol
@@ -1462,59 +1686,6 @@ module ts {
         });
     }
 
-    export function symbolPart(text: string, symbol: Symbol) {
-        return displayPart(text, displayPartKind(symbol), symbol);
-
-        function displayPartKind(symbol: Symbol): SymbolDisplayPartKind {
-            var flags = symbol.flags;
-
-            if (flags & SymbolFlags.Variable) {
-                return isFirstDeclarationOfSymbolParameter(symbol) ? SymbolDisplayPartKind.parameterName : SymbolDisplayPartKind.localName;
-            }
-            else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; }
-            else if (flags & SymbolFlags.GetAccessor) { return SymbolDisplayPartKind.propertyName; }
-            else if (flags & SymbolFlags.SetAccessor) { return SymbolDisplayPartKind.propertyName; }
-            else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; }
-            else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; }
-            else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; }
-            else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; }
-            else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; }
-            else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; }
-            else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; }
-            else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; }
-            else if (flags & SymbolFlags.TypeAlias) { return SymbolDisplayPartKind.aliasName; }
-            else if (flags & SymbolFlags.Import) { return SymbolDisplayPartKind.aliasName; }
-
-
-            return SymbolDisplayPartKind.text;
-        }
-    }
-
-    export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] {
-        writeDisplayParts(displayPartWriter);
-        var result = displayPartWriter.displayParts();
-        displayPartWriter.clear();
-        return result;
-    }
-
-    export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
-        return mapToDisplayParts(writer => {
-            typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
-        });
-    }
-
-    export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[] {
-        return mapToDisplayParts(writer => {
-            typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags);
-        });
-    }
-
-    function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[]{
-        return mapToDisplayParts(writer => {
-            typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
-        });
-    }
-
     export function getDefaultCompilerOptions(): CompilerOptions {
         // Set "ScriptTarget.Latest" target by default for language service
         return {
@@ -1523,20 +1694,6 @@ module ts {
         };
     }
 
-    export function compareDataObjects(dst: any, src: any): boolean {
-        for (var e in dst) {
-            if (typeof dst[e] === "object") {
-                if (!compareDataObjects(dst[e], src[e]))
-                    return false;
-            }
-            else if (typeof dst[e] !== "function") {
-                if (dst[e] !== src[e])
-                    return false;
-            }
-        }
-        return true;
-    }
-
     export class OperationCanceledException { }
 
     export class CancellationTokenObject {
@@ -1893,20 +2050,6 @@ module ts {
     }
 
     /// Helpers
-    export function getNodeModifiers(node: Node): string {
-        var flags = node.flags;
-        var result: string[] = [];
-
-        if (flags & NodeFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier);
-        if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier);
-        if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier);
-        if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier);
-        if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier);
-        if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier);
-
-        return result.length > 0 ? result.join(',') : ScriptElementKindModifier.none;
-    }
-
     function getTargetLabel(referenceNode: Node, labelName: string): Identifier {
         while (referenceNode) {
             if (referenceNode.kind === SyntaxKind.LabeledStatement && (<LabeledStatement>referenceNode).label.text === labelName) {
@@ -2084,12 +2227,12 @@ module ts {
         var useCaseSensitivefilenames = false;
         var sourceFilesByName: Map<SourceFile> = {};
         var documentRegistry = documentRegistry;
-        var cancellationToken = new CancellationTokenObject(host.getCancellationToken());
+        var cancellationToken = new CancellationTokenObject(host.getCancellationToken && host.getCancellationToken());
         var activeCompletionSession: CompletionSession;         // The current active completion session, used to get the completion entry details
         var writer: (filename: string, data: string, writeByteOrderMark: boolean) => void = undefined;
 
         // Check if the localized messages json is set, otherwise query the host for it
-        if (!localizedDiagnosticMessages) {
+        if (!localizedDiagnosticMessages && host.getLocalizedDiagnosticMessages) {
             localizedDiagnosticMessages = host.getLocalizedDiagnosticMessages();
         }
 
@@ -2355,7 +2498,7 @@ module ts {
             };
         }
 
-        function getCompletionsAtPosition(filename: string, position: number, isMemberCompletion: boolean) {
+        function getCompletionsAtPosition(filename: string, position: number) {
             synchronizeHostData();
 
             filename = normalizeSlashes(filename);
@@ -2430,7 +2573,7 @@ module ts {
             if (isRightOfDot) {
                 // Right of dot member completion list
                 var symbols: Symbol[] = [];
-                isMemberCompletion = true;
+                var isMemberCompletion = true;
 
                 if (node.kind === SyntaxKind.Identifier || node.kind === SyntaxKind.QualifiedName || node.kind === SyntaxKind.PropertyAccessExpression) {
                     var symbol = typeInfoResolver.getSymbolAtLocation(node);
diff --git a/src/services/shims.ts b/src/services/shims.ts
index a86d1f5231d..e1eb388321a 100644
--- a/src/services/shims.ts
+++ b/src/services/shims.ts
@@ -88,7 +88,7 @@ module ts {
 
         getSyntacticClassifications(fileName: string, start: number, length: number): string;
 
-        getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean): string;
+        getCompletionsAtPosition(fileName: string, position: number): string;
         getCompletionEntryDetails(fileName: string, position: number, entryName: string): string;
 
         getQuickInfoAtPosition(fileName: string, position: number): string;
@@ -559,11 +559,11 @@ module ts {
          * to provide at the given source position and providing a member completion 
          * list if requested.
          */
-        public getCompletionsAtPosition(fileName: string, position: number, isMemberCompletion: boolean) {
+        public getCompletionsAtPosition(fileName: string, position: number) {
             return this.forwardJSONCall(
-                "getCompletionsAtPosition('" + fileName + "', " + position + ", " + isMemberCompletion + ")",
+                "getCompletionsAtPosition('" + fileName + "', " + position + ")",
                 () => {
-                    var completion = this.languageService.getCompletionsAtPosition(fileName, position, isMemberCompletion);
+                    var completion = this.languageService.getCompletionsAtPosition(fileName, position);
                     return completion;
                 });
         }
@@ -732,6 +732,13 @@ module ts {
         private _shims: Shim[] = [];
         private documentRegistry: DocumentRegistry = createDocumentRegistry();
 
+        /*
+         * Returns script API version.
+         */
+        public getServicesVersion(): string {
+            return servicesVersion;
+        }
+
         public createLanguageServiceShim(host: LanguageServiceShimHost): LanguageServiceShim {
             try {
                 var hostAdapter = new LanguageServiceShimHostAdapter(host);
diff --git a/src/services/text.ts b/src/services/text.ts
deleted file mode 100644
index fd768785dea..00000000000
--- a/src/services/text.ts
+++ /dev/null
@@ -1,296 +0,0 @@
-module ts {
-    export class TextSpan {
-        private _start: number;
-        private _length: number;
-
-        /**
-         * Creates a TextSpan instance beginning with the position Start and having the Length
-         * specified with length.
-         */
-        constructor(start: number, length: number) {
-            Debug.assert(start >= 0, "start");
-            Debug.assert(length >= 0, "length");
-
-            this._start = start;
-            this._length = length;
-        }
-
-        public toJSON(key: any): any {
-            return { start: this._start, length: this._length };
-        }
-
-        public start(): number {
-            return this._start;
-        }
-
-        public length(): number {
-            return this._length;
-        }
-
-        public end(): number {
-            return this._start + this._length;
-        }
-
-        public isEmpty(): boolean {
-            return this._length === 0;
-        }
-
-        /**
-         * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less 
-         * than End, otherwise false.
-         * @param position The position to check.
-         */
-        public containsPosition(position: number): boolean {
-            return position >= this._start && position < this.end();
-        }
-
-        /**
-         * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.
-         * @param span The span to check.
-         */
-        public containsTextSpan(span: TextSpan): boolean {
-            return span._start >= this._start && span.end() <= this.end();
-        }
-
-        /**
-         * Determines whether the given span overlaps this span. Two spans are considered to overlap 
-         * if they have positions in common and neither is empty. Empty spans do not overlap with any 
-         * other span. Returns true if the spans overlap, false otherwise.
-         * @param span The span to check.
-         */
-        public overlapsWith(span: TextSpan): boolean {
-            var overlapStart = Math.max(this._start, span._start);
-            var overlapEnd = Math.min(this.end(), span.end());
-
-            return overlapStart < overlapEnd;
-        }
-
-        /**
-         * Returns the overlap with the given span, or undefined if there is no overlap.
-         * @param span The span to check.
-         */
-        public overlap(span: TextSpan): TextSpan {
-            var overlapStart = Math.max(this._start, span._start);
-            var overlapEnd = Math.min(this.end(), span.end());
-
-            if (overlapStart < overlapEnd) {
-                return TextSpan.fromBounds(overlapStart, overlapEnd);
-            }
-
-            return undefined;
-        }
-
-        /**
-         * Determines whether span intersects this span. Two spans are considered to 
-         * intersect if they have positions in common or the end of one span 
-         * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.
-         * @param The span to check.
-         */
-        public intersectsWithTextSpan(span: TextSpan): boolean {
-            return span._start <= this.end() && span.end() >= this._start;
-        }
-
-        public intersectsWith(start: number, length: number): boolean {
-            var end = start + length;
-            return start <= this.end() && end >= this._start;
-        }
-
-        /**
-         * Determines whether the given position intersects this span. 
-         * A position is considered to intersect if it is between the start and
-         * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.
-         * @param position The position to check.
-         */
-        public intersectsWithPosition(position: number): boolean {
-            return position <= this.end() && position >= this._start;
-        }
-
-        /**
-         * Returns the intersection with the given span, or undefined if there is no intersection.
-         * @param span The span to check.
-         */
-        public intersection(span: TextSpan): TextSpan {
-            var intersectStart = Math.max(this._start, span._start);
-            var intersectEnd = Math.min(this.end(), span.end());
-
-            if (intersectStart <= intersectEnd) {
-                return TextSpan.fromBounds(intersectStart, intersectEnd);
-            }
-
-            return undefined;
-        }
-
-        /**
-         * Creates a new TextSpan from the given start and end positions
-         * as opposed to a position and length.
-         */
-        public static fromBounds(start: number, end: number): TextSpan {
-            Debug.assert(start >= 0);
-            Debug.assert(end - start >= 0);
-            return new TextSpan(start, end - start);
-        }
-    }
-
-    export class TextChangeRange {
-        public static unchanged = new TextChangeRange(new TextSpan(0, 0), 0);
-
-        private _span: TextSpan;
-        private _newLength: number;
-
-        /**
-         * Initializes a new instance of TextChangeRange.
-         */
-        constructor(span: TextSpan, newLength: number) {
-            Debug.assert(newLength >= 0, "newLength");
-
-            this._span = span;
-            this._newLength = newLength;
-        }
-
-        /**
-         * The span of text before the edit which is being changed
-         */
-        public span(): TextSpan {
-            return this._span;
-        }
-
-        /**
-         * Width of the span after the edit.  A 0 here would represent a delete
-         */
-        public newLength(): number {
-            return this._newLength;
-        }
-
-        public newSpan(): TextSpan {
-            return new TextSpan(this.span().start(), this.newLength());
-        }
-
-        public isUnchanged(): boolean {
-            return this.span().isEmpty() && this.newLength() === 0;
-        }
-
-        /**
-         * Called to merge all the changes that occurred across several versions of a script snapshot 
-         * into a single change.  i.e. if a user keeps making successive edits to a script we will
-         * have a text change from V1 to V2, V2 to V3, ..., Vn.  
-         * 
-         * This function will then merge those changes into a single change range valid between V1 and
-         * Vn.
-         */
-        public static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange {
-            if (changes.length === 0) {
-                return TextChangeRange.unchanged;
-            }
-
-            if (changes.length === 1) {
-                return changes[0];
-            }
-
-            // We change from talking about { { oldStart, oldLength }, newLength } to { oldStart, oldEnd, newEnd }
-            // as it makes things much easier to reason about.
-            var change0 = changes[0];
-
-            var oldStartN = change0.span().start();
-            var oldEndN = change0.span().end();
-            var newEndN = oldStartN + change0.newLength();
-
-            for (var i = 1; i < changes.length; i++) {
-                var nextChange = changes[i];
-
-                // Consider the following case:
-                // i.e. two edits.  The first represents the text change range { { 10, 50 }, 30 }.  i.e. The span starting
-                // at 10, with length 50 is reduced to length 30.  The second represents the text change range { { 30, 30 }, 40 }.
-                // i.e. the span starting at 30 with length 30 is increased to length 40.
-                //
-                //      0         10        20        30        40        50        60        70        80        90        100
-                //      -------------------------------------------------------------------------------------------------------
-                //                |                                                 /                                          
-                //                |                                            /----                                           
-                //  T1            |                                       /----                                                
-                //                |                                  /----                                                     
-                //                |                             /----                                                          
-                //      -------------------------------------------------------------------------------------------------------
-                //                                     |                            \                                          
-                //                                     |                               \                                       
-                //   T2                                |                                 \                                     
-                //                                     |                                   \                                   
-                //                                     |                                      \                                
-                //      -------------------------------------------------------------------------------------------------------
-                //
-                // Merging these turns out to not be too difficult.  First, determining the new start of the change is trivial
-                // it's just the min of the old and new starts.  i.e.:
-                //
-                //      0         10        20        30        40        50        60        70        80        90        100
-                //      ------------------------------------------------------------*------------------------------------------
-                //                |                                                 /                                          
-                //                |                                            /----                                           
-                //  T1            |                                       /----                                                
-                //                |                                  /----                                                     
-                //                |                             /----                                                          
-                //      ----------------------------------------$-------------------$------------------------------------------
-                //                .                    |                            \                                          
-                //                .                    |                               \                                       
-                //   T2           .                    |                                 \                                     
-                //                .                    |                                   \                                   
-                //                .                    |                                      \                                
-                //      ----------------------------------------------------------------------*--------------------------------
-                //
-                // (Note the dots represent the newly inferrred start.
-                // Determining the new and old end is also pretty simple.  Basically it boils down to paying attention to the
-                // absolute positions at the asterixes, and the relative change between the dollar signs. Basically, we see
-                // which if the two $'s precedes the other, and we move that one forward until they line up.  in this case that
-                // means:
-                //
-                //      0         10        20        30        40        50        60        70        80        90        100
-                //      --------------------------------------------------------------------------------*----------------------
-                //                |                                                                     /                      
-                //                |                                                                /----                       
-                //  T1            |                                                           /----                            
-                //                |                                                      /----                                 
-                //                |                                                 /----                                      
-                //      ------------------------------------------------------------$------------------------------------------
-                //                .                    |                            \                                          
-                //                .                    |                               \                                       
-                //   T2           .                    |                                 \                                     
-                //                .                    |                                   \                                   
-                //                .                    |                                      \                                
-                //      ----------------------------------------------------------------------*--------------------------------
-                //
-                // In other words (in this case), we're recognizing that the second edit happened after where the first edit
-                // ended with a delta of 20 characters (60 - 40).  Thus, if we go back in time to where the first edit started
-                // that's the same as if we started at char 80 instead of 60.  
-                //
-                // As it so happens, the same logic applies if the second edit precedes the first edit.  In that case rahter
-                // than pusing the first edit forward to match the second, we'll push the second edit forward to match the
-                // first.
-                //
-                // In this case that means we have { oldStart: 10, oldEnd: 80, newEnd: 70 } or, in TextChangeRange
-                // semantics: { { start: 10, length: 70 }, newLength: 60 }
-                //
-                // The math then works out as follows.
-                // If we have { oldStart1, oldEnd1, newEnd1 } and { oldStart2, oldEnd2, newEnd2 } then we can compute the 
-                // final result like so:
-                //
-                // {
-                //      oldStart3: Min(oldStart1, oldStart2),
-                //      oldEnd3  : Max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1)),
-                //      newEnd3  : Max(newEnd2, newEnd2 + (newEnd1 - oldEnd2))
-                // }
-
-                var oldStart1 = oldStartN;
-                var oldEnd1 = oldEndN;
-                var newEnd1 = newEndN;
-
-                var oldStart2 = nextChange.span().start();
-                var oldEnd2 = nextChange.span().end();
-                var newEnd2 = oldStart2 + nextChange.newLength();
-
-                oldStartN = Math.min(oldStart1, oldStart2);
-                oldEndN = Math.max(oldEnd1, oldEnd1 + (oldEnd2 - newEnd1));
-                newEndN = Math.max(newEnd2, newEnd2 + (newEnd1 - oldEnd2));
-            }
-
-            return new TextChangeRange(TextSpan.fromBounds(oldStartN, oldEndN), /*newLength: */newEndN - oldStartN);
-        }
-    }
-}
\ No newline at end of file
diff --git a/src/services/utilities.ts b/src/services/utilities.ts
index 32551d9737b..146ea141d76 100644
--- a/src/services/utilities.ts
+++ b/src/services/utilities.ts
@@ -270,7 +270,21 @@ module ts {
         return n.getWidth() !== 0;
     }
 
-   export function getTypeArgumentOrTypeParameterList(node: Node): NodeArray<Node> {
+    export function getNodeModifiers(node: Node): string {
+        var flags = node.flags;
+        var result: string[] = [];
+
+        if (flags & NodeFlags.Private) result.push(ScriptElementKindModifier.privateMemberModifier);
+        if (flags & NodeFlags.Protected) result.push(ScriptElementKindModifier.protectedMemberModifier);
+        if (flags & NodeFlags.Public) result.push(ScriptElementKindModifier.publicMemberModifier);
+        if (flags & NodeFlags.Static) result.push(ScriptElementKindModifier.staticModifier);
+        if (flags & NodeFlags.Export) result.push(ScriptElementKindModifier.exportedModifier);
+        if (isInAmbientContext(node)) result.push(ScriptElementKindModifier.ambientModifier);
+
+        return result.length > 0 ? result.join(',') : ScriptElementKindModifier.none;
+    }
+
+    export function getTypeArgumentOrTypeParameterList(node: Node): NodeArray<Node> {
         if (node.kind === SyntaxKind.TypeReference || node.kind === SyntaxKind.CallExpression) {
             return (<CallExpression>node).typeArguments;
         }
@@ -306,4 +320,166 @@ module ts {
         return isTemplateLiteralKind(node.kind)
             && (node.getStart() < position && position < node.getEnd()) || (!!node.isUnterminated && position === node.getEnd());
     }
+
+    export function compareDataObjects(dst: any, src: any): boolean {
+        for (var e in dst) {
+            if (typeof dst[e] === "object") {
+                if (!compareDataObjects(dst[e], src[e])) {
+                    return false;
+                }
+            }
+            else if (typeof dst[e] !== "function") {
+                if (dst[e] !== src[e]) {
+                    return false;
+                }
+            }
+        }
+        return true;
+    }
+}
+
+// Display-part writer helpers
+module ts {
+    export function isFirstDeclarationOfSymbolParameter(symbol: Symbol) {
+        return symbol.declarations && symbol.declarations.length > 0 && symbol.declarations[0].kind === SyntaxKind.Parameter;
+    }
+
+    var displayPartWriter = getDisplayPartWriter();
+    function getDisplayPartWriter(): DisplayPartsSymbolWriter {
+        var displayParts: SymbolDisplayPart[];
+        var lineStart: boolean;
+        var indent: number;
+
+        resetWriter();
+        return {
+            displayParts: () => displayParts,
+            writeKeyword: text => writeKind(text, SymbolDisplayPartKind.keyword),
+            writeOperator: text => writeKind(text, SymbolDisplayPartKind.operator),
+            writePunctuation: text => writeKind(text, SymbolDisplayPartKind.punctuation),
+            writeSpace: text => writeKind(text, SymbolDisplayPartKind.space),
+            writeStringLiteral: text => writeKind(text, SymbolDisplayPartKind.stringLiteral),
+            writeParameter: text => writeKind(text, SymbolDisplayPartKind.parameterName),
+            writeSymbol,
+            writeLine,
+            increaseIndent: () => { indent++; },
+            decreaseIndent: () => { indent--; },
+            clear: resetWriter,
+            trackSymbol: () => { }
+        };
+
+        function writeIndent() {
+            if (lineStart) {
+                var indentString = getIndentString(indent);
+                if (indentString) {
+                    displayParts.push(displayPart(indentString, SymbolDisplayPartKind.space));
+                }
+                lineStart = false;
+            }
+        }
+
+        function writeKind(text: string, kind: SymbolDisplayPartKind) {
+            writeIndent();
+            displayParts.push(displayPart(text, kind));
+        }
+
+        function writeSymbol(text: string, symbol: Symbol) {
+            writeIndent();
+            displayParts.push(symbolPart(text, symbol));
+        }
+
+        function writeLine() {
+            displayParts.push(lineBreakPart());
+            lineStart = true;
+        }
+
+        function resetWriter() {
+            displayParts = []
+            lineStart = true;
+            indent = 0;
+        }
+    }
+
+    export function symbolPart(text: string, symbol: Symbol) {
+        return displayPart(text, displayPartKind(symbol), symbol);
+
+        function displayPartKind(symbol: Symbol): SymbolDisplayPartKind {
+            var flags = symbol.flags;
+
+            if (flags & SymbolFlags.Variable) {
+                return isFirstDeclarationOfSymbolParameter(symbol) ? SymbolDisplayPartKind.parameterName : SymbolDisplayPartKind.localName;
+            }
+            else if (flags & SymbolFlags.Property) { return SymbolDisplayPartKind.propertyName; }
+            else if (flags & SymbolFlags.GetAccessor) { return SymbolDisplayPartKind.propertyName; }
+            else if (flags & SymbolFlags.SetAccessor) { return SymbolDisplayPartKind.propertyName; }
+            else if (flags & SymbolFlags.EnumMember) { return SymbolDisplayPartKind.enumMemberName; }
+            else if (flags & SymbolFlags.Function) { return SymbolDisplayPartKind.functionName; }
+            else if (flags & SymbolFlags.Class) { return SymbolDisplayPartKind.className; }
+            else if (flags & SymbolFlags.Interface) { return SymbolDisplayPartKind.interfaceName; }
+            else if (flags & SymbolFlags.Enum) { return SymbolDisplayPartKind.enumName; }
+            else if (flags & SymbolFlags.Module) { return SymbolDisplayPartKind.moduleName; }
+            else if (flags & SymbolFlags.Method) { return SymbolDisplayPartKind.methodName; }
+            else if (flags & SymbolFlags.TypeParameter) { return SymbolDisplayPartKind.typeParameterName; }
+            else if (flags & SymbolFlags.TypeAlias) { return SymbolDisplayPartKind.aliasName; }
+            else if (flags & SymbolFlags.Import) { return SymbolDisplayPartKind.aliasName; }
+
+
+            return SymbolDisplayPartKind.text;
+        }
+    }
+
+    export function displayPart(text: string, kind: SymbolDisplayPartKind, symbol?: Symbol): SymbolDisplayPart {
+        return <SymbolDisplayPart> {
+            text: text,
+            kind: SymbolDisplayPartKind[kind]
+        };
+    }
+
+    export function spacePart() {
+        return displayPart(" ", SymbolDisplayPartKind.space);
+    }
+
+    export function keywordPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.keyword);
+    }
+
+    export function punctuationPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.punctuation);
+    }
+
+    export function operatorPart(kind: SyntaxKind) {
+        return displayPart(tokenToString(kind), SymbolDisplayPartKind.operator);
+    }
+
+    export function textPart(text: string) {
+        return displayPart(text, SymbolDisplayPartKind.text);
+    }
+
+    export function lineBreakPart() {
+        return displayPart("\n", SymbolDisplayPartKind.lineBreak);
+    }
+
+    export function mapToDisplayParts(writeDisplayParts: (writer: DisplayPartsSymbolWriter) => void): SymbolDisplayPart[] {
+        writeDisplayParts(displayPartWriter);
+        var result = displayPartWriter.displayParts();
+        displayPartWriter.clear();
+        return result;
+    }
+
+    export function typeToDisplayParts(typechecker: TypeChecker, type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
+        return mapToDisplayParts(writer => {
+            typechecker.getSymbolDisplayBuilder().buildTypeDisplay(type, writer, enclosingDeclaration, flags);
+        });
+    }
+
+    export function symbolToDisplayParts(typeChecker: TypeChecker, symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): SymbolDisplayPart[] {
+        return mapToDisplayParts(writer => {
+            typeChecker.getSymbolDisplayBuilder().buildSymbolDisplay(symbol, writer, enclosingDeclaration, meaning, flags);
+        });
+    }
+
+    export function signatureToDisplayParts(typechecker: TypeChecker, signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags): SymbolDisplayPart[] {
+        return mapToDisplayParts(writer => {
+            typechecker.getSymbolDisplayBuilder().buildSignatureDisplay(signature, writer, enclosingDeclaration, flags);
+        });
+    }
 }
\ No newline at end of file
diff --git a/tests/baselines/reference/APISample_node_compile.js b/tests/baselines/reference/APISample_node_compile.js
new file mode 100644
index 00000000000..d4111bcafd4
--- /dev/null
+++ b/tests/baselines/reference/APISample_node_compile.js
@@ -0,0 +1,1865 @@
+//// [tests/cases/compiler/APISample_node_compile.ts] ////
+
+//// [APISample_node_compile.ts]
+
+import ts = require("typescript");
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
+//// [typescript.d.ts]
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+declare module "typescript" {
+    interface Map<T> {
+        [index: string]: T;
+    }
+    interface TextRange {
+        pos: number;
+        end: number;
+    }
+    const enum SyntaxKind {
+        Unknown = 0,
+        EndOfFileToken = 1,
+        SingleLineCommentTrivia = 2,
+        MultiLineCommentTrivia = 3,
+        NewLineTrivia = 4,
+        WhitespaceTrivia = 5,
+        NumericLiteral = 6,
+        StringLiteral = 7,
+        RegularExpressionLiteral = 8,
+        NoSubstitutionTemplateLiteral = 9,
+        TemplateHead = 10,
+        TemplateMiddle = 11,
+        TemplateTail = 12,
+        OpenBraceToken = 13,
+        CloseBraceToken = 14,
+        OpenParenToken = 15,
+        CloseParenToken = 16,
+        OpenBracketToken = 17,
+        CloseBracketToken = 18,
+        DotToken = 19,
+        DotDotDotToken = 20,
+        SemicolonToken = 21,
+        CommaToken = 22,
+        LessThanToken = 23,
+        GreaterThanToken = 24,
+        LessThanEqualsToken = 25,
+        GreaterThanEqualsToken = 26,
+        EqualsEqualsToken = 27,
+        ExclamationEqualsToken = 28,
+        EqualsEqualsEqualsToken = 29,
+        ExclamationEqualsEqualsToken = 30,
+        EqualsGreaterThanToken = 31,
+        PlusToken = 32,
+        MinusToken = 33,
+        AsteriskToken = 34,
+        SlashToken = 35,
+        PercentToken = 36,
+        PlusPlusToken = 37,
+        MinusMinusToken = 38,
+        LessThanLessThanToken = 39,
+        GreaterThanGreaterThanToken = 40,
+        GreaterThanGreaterThanGreaterThanToken = 41,
+        AmpersandToken = 42,
+        BarToken = 43,
+        CaretToken = 44,
+        ExclamationToken = 45,
+        TildeToken = 46,
+        AmpersandAmpersandToken = 47,
+        BarBarToken = 48,
+        QuestionToken = 49,
+        ColonToken = 50,
+        EqualsToken = 51,
+        PlusEqualsToken = 52,
+        MinusEqualsToken = 53,
+        AsteriskEqualsToken = 54,
+        SlashEqualsToken = 55,
+        PercentEqualsToken = 56,
+        LessThanLessThanEqualsToken = 57,
+        GreaterThanGreaterThanEqualsToken = 58,
+        GreaterThanGreaterThanGreaterThanEqualsToken = 59,
+        AmpersandEqualsToken = 60,
+        BarEqualsToken = 61,
+        CaretEqualsToken = 62,
+        Identifier = 63,
+        BreakKeyword = 64,
+        CaseKeyword = 65,
+        CatchKeyword = 66,
+        ClassKeyword = 67,
+        ConstKeyword = 68,
+        ContinueKeyword = 69,
+        DebuggerKeyword = 70,
+        DefaultKeyword = 71,
+        DeleteKeyword = 72,
+        DoKeyword = 73,
+        ElseKeyword = 74,
+        EnumKeyword = 75,
+        ExportKeyword = 76,
+        ExtendsKeyword = 77,
+        FalseKeyword = 78,
+        FinallyKeyword = 79,
+        ForKeyword = 80,
+        FunctionKeyword = 81,
+        IfKeyword = 82,
+        ImportKeyword = 83,
+        InKeyword = 84,
+        InstanceOfKeyword = 85,
+        NewKeyword = 86,
+        NullKeyword = 87,
+        ReturnKeyword = 88,
+        SuperKeyword = 89,
+        SwitchKeyword = 90,
+        ThisKeyword = 91,
+        ThrowKeyword = 92,
+        TrueKeyword = 93,
+        TryKeyword = 94,
+        TypeOfKeyword = 95,
+        VarKeyword = 96,
+        VoidKeyword = 97,
+        WhileKeyword = 98,
+        WithKeyword = 99,
+        ImplementsKeyword = 100,
+        InterfaceKeyword = 101,
+        LetKeyword = 102,
+        PackageKeyword = 103,
+        PrivateKeyword = 104,
+        ProtectedKeyword = 105,
+        PublicKeyword = 106,
+        StaticKeyword = 107,
+        YieldKeyword = 108,
+        AnyKeyword = 109,
+        BooleanKeyword = 110,
+        ConstructorKeyword = 111,
+        DeclareKeyword = 112,
+        GetKeyword = 113,
+        ModuleKeyword = 114,
+        RequireKeyword = 115,
+        NumberKeyword = 116,
+        SetKeyword = 117,
+        StringKeyword = 118,
+        TypeKeyword = 119,
+        QualifiedName = 120,
+        ComputedPropertyName = 121,
+        TypeParameter = 122,
+        Parameter = 123,
+        Property = 124,
+        Method = 125,
+        Constructor = 126,
+        GetAccessor = 127,
+        SetAccessor = 128,
+        CallSignature = 129,
+        ConstructSignature = 130,
+        IndexSignature = 131,
+        TypeReference = 132,
+        FunctionType = 133,
+        ConstructorType = 134,
+        TypeQuery = 135,
+        TypeLiteral = 136,
+        ArrayType = 137,
+        TupleType = 138,
+        UnionType = 139,
+        ParenthesizedType = 140,
+        ArrayLiteralExpression = 141,
+        ObjectLiteralExpression = 142,
+        PropertyAccessExpression = 143,
+        ElementAccessExpression = 144,
+        CallExpression = 145,
+        NewExpression = 146,
+        TaggedTemplateExpression = 147,
+        TypeAssertionExpression = 148,
+        ParenthesizedExpression = 149,
+        FunctionExpression = 150,
+        ArrowFunction = 151,
+        DeleteExpression = 152,
+        TypeOfExpression = 153,
+        VoidExpression = 154,
+        PrefixUnaryExpression = 155,
+        PostfixUnaryExpression = 156,
+        BinaryExpression = 157,
+        ConditionalExpression = 158,
+        TemplateExpression = 159,
+        YieldExpression = 160,
+        OmittedExpression = 161,
+        TemplateSpan = 162,
+        Block = 163,
+        VariableStatement = 164,
+        EmptyStatement = 165,
+        ExpressionStatement = 166,
+        IfStatement = 167,
+        DoStatement = 168,
+        WhileStatement = 169,
+        ForStatement = 170,
+        ForInStatement = 171,
+        ContinueStatement = 172,
+        BreakStatement = 173,
+        ReturnStatement = 174,
+        WithStatement = 175,
+        SwitchStatement = 176,
+        LabeledStatement = 177,
+        ThrowStatement = 178,
+        TryStatement = 179,
+        TryBlock = 180,
+        FinallyBlock = 181,
+        DebuggerStatement = 182,
+        VariableDeclaration = 183,
+        FunctionDeclaration = 184,
+        ClassDeclaration = 185,
+        InterfaceDeclaration = 186,
+        TypeAliasDeclaration = 187,
+        EnumDeclaration = 188,
+        ModuleDeclaration = 189,
+        ModuleBlock = 190,
+        ImportDeclaration = 191,
+        ExportAssignment = 192,
+        ExternalModuleReference = 193,
+        CaseClause = 194,
+        DefaultClause = 195,
+        HeritageClause = 196,
+        CatchClause = 197,
+        PropertyAssignment = 198,
+        ShorthandPropertyAssignment = 199,
+        EnumMember = 200,
+        SourceFile = 201,
+        Program = 202,
+        SyntaxList = 203,
+        Count = 204,
+        FirstAssignment = 51,
+        LastAssignment = 62,
+        FirstReservedWord = 64,
+        LastReservedWord = 99,
+        FirstKeyword = 64,
+        LastKeyword = 119,
+        FirstFutureReservedWord = 100,
+        LastFutureReservedWord = 108,
+        FirstTypeNode = 132,
+        LastTypeNode = 140,
+        FirstPunctuation = 13,
+        LastPunctuation = 62,
+        FirstToken = 0,
+        LastToken = 119,
+        FirstTriviaToken = 2,
+        LastTriviaToken = 5,
+        FirstLiteralToken = 6,
+        LastLiteralToken = 9,
+        FirstTemplateToken = 9,
+        LastTemplateToken = 12,
+        FirstOperator = 21,
+        LastOperator = 62,
+        FirstBinaryOperator = 23,
+        LastBinaryOperator = 62,
+        FirstNode = 120,
+    }
+    const enum NodeFlags {
+        Export = 1,
+        Ambient = 2,
+        Public = 16,
+        Private = 32,
+        Protected = 64,
+        Static = 128,
+        MultiLine = 256,
+        Synthetic = 512,
+        DeclarationFile = 1024,
+        Let = 2048,
+        Const = 4096,
+        OctalLiteral = 8192,
+        Modifier = 243,
+        AccessibilityModifier = 112,
+        BlockScoped = 6144,
+    }
+    const enum ParserContextFlags {
+        StrictMode = 1,
+        DisallowIn = 2,
+        Yield = 4,
+        GeneratorParameter = 8,
+        ContainsError = 16,
+        HasPropagatedChildContainsErrorFlag = 32,
+    }
+    interface Node extends TextRange {
+        kind: SyntaxKind;
+        flags: NodeFlags;
+        parserContextFlags?: ParserContextFlags;
+        id?: number;
+        parent?: Node;
+        symbol?: Symbol;
+        locals?: SymbolTable;
+        nextContainer?: Node;
+        localSymbol?: Symbol;
+        modifiers?: ModifiersArray;
+    }
+    interface NodeArray<T> extends Array<T>, TextRange {
+        hasTrailingComma?: boolean;
+    }
+    interface ModifiersArray extends NodeArray<Node> {
+        flags: number;
+    }
+    interface Identifier extends PrimaryExpression {
+        text: string;
+    }
+    interface QualifiedName extends Node {
+        left: EntityName;
+        right: Identifier;
+    }
+    type EntityName = Identifier | QualifiedName;
+    type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName;
+    interface Declaration extends Node {
+        _declarationBrand: any;
+        name?: DeclarationName;
+    }
+    interface ComputedPropertyName extends Node {
+        expression: Expression;
+    }
+    interface TypeParameterDeclaration extends Declaration {
+        name: Identifier;
+        constraint?: TypeNode;
+        expression?: Expression;
+    }
+    interface SignatureDeclaration extends Declaration {
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        parameters: NodeArray<ParameterDeclaration>;
+        type?: TypeNode;
+    }
+    interface VariableDeclaration extends Declaration {
+        name: Identifier;
+        type?: TypeNode;
+        initializer?: Expression;
+    }
+    interface ParameterDeclaration extends Declaration {
+        dotDotDotToken?: Node;
+        name: Identifier;
+        questionToken?: Node;
+        type?: TypeNode | StringLiteralExpression;
+        initializer?: Expression;
+    }
+    interface PropertyDeclaration extends Declaration, ClassElement {
+        _propertyDeclarationBrand: any;
+        questionToken?: Node;
+        type?: TypeNode;
+        initializer?: Expression;
+    }
+    type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration;
+    type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration;
+    interface ObjectLiteralElement extends Declaration {
+        _objectLiteralBrandBrand: any;
+    }
+    interface ShorthandPropertyAssignment extends ObjectLiteralElement {
+        name: Identifier;
+        questionToken?: Node;
+    }
+    interface PropertyAssignment extends ObjectLiteralElement {
+        _propertyAssignmentBrand: any;
+        name: DeclarationName;
+        questionToken?: Node;
+        initializer: Expression;
+    }
+    /**
+     * Several node kinds share function-like features such as a signature,
+     * a name, and a body. These nodes should extend FunctionLikeDeclaration.
+     * Examples:
+     *  FunctionDeclaration
+     *  MethodDeclaration
+     *  AccessorDeclaration
+     */
+    interface FunctionLikeDeclaration extends SignatureDeclaration {
+        _functionLikeDeclarationBrand: any;
+        asteriskToken?: Node;
+        questionToken?: Node;
+        body?: Block | Expression;
+    }
+    interface FunctionDeclaration extends FunctionLikeDeclaration, Statement {
+        name: Identifier;
+        body?: Block;
+    }
+    interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
+        body?: Block;
+    }
+    interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
+        body?: Block;
+    }
+    interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
+        _accessorDeclarationBrand: any;
+        body: Block;
+    }
+    interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement {
+        _indexSignatureDeclarationBrand: any;
+    }
+    interface TypeNode extends Node {
+        _typeNodeBrand: any;
+    }
+    interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {
+        _functionOrConstructorTypeNodeBrand: any;
+    }
+    interface TypeReferenceNode extends TypeNode {
+        typeName: EntityName;
+        typeArguments?: NodeArray<TypeNode>;
+    }
+    interface TypeQueryNode extends TypeNode {
+        exprName: EntityName;
+    }
+    interface TypeLiteralNode extends TypeNode, Declaration {
+        members: NodeArray<Node>;
+    }
+    interface ArrayTypeNode extends TypeNode {
+        elementType: TypeNode;
+    }
+    interface TupleTypeNode extends TypeNode {
+        elementTypes: NodeArray<TypeNode>;
+    }
+    interface UnionTypeNode extends TypeNode {
+        types: NodeArray<TypeNode>;
+    }
+    interface ParenthesizedTypeNode extends TypeNode {
+        type: TypeNode;
+    }
+    interface Expression extends Node {
+        _expressionBrand: any;
+        contextualType?: Type;
+    }
+    interface UnaryExpression extends Expression {
+        _unaryExpressionBrand: any;
+    }
+    interface PrefixUnaryExpression extends UnaryExpression {
+        operator: SyntaxKind;
+        operand: UnaryExpression;
+    }
+    interface PostfixUnaryExpression extends PostfixExpression {
+        operand: LeftHandSideExpression;
+        operator: SyntaxKind;
+    }
+    interface PostfixExpression extends UnaryExpression {
+        _postfixExpressionBrand: any;
+    }
+    interface LeftHandSideExpression extends PostfixExpression {
+        _leftHandSideExpressionBrand: any;
+    }
+    interface MemberExpression extends LeftHandSideExpression {
+        _memberExpressionBrand: any;
+    }
+    interface PrimaryExpression extends MemberExpression {
+        _primaryExpressionBrand: any;
+    }
+    interface DeleteExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface TypeOfExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface VoidExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface YieldExpression extends Expression {
+        asteriskToken?: Node;
+        expression: Expression;
+    }
+    interface BinaryExpression extends Expression {
+        left: Expression;
+        operator: SyntaxKind;
+        right: Expression;
+    }
+    interface ConditionalExpression extends Expression {
+        condition: Expression;
+        whenTrue: Expression;
+        whenFalse: Expression;
+    }
+    interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {
+        name?: Identifier;
+        body: Block | Expression;
+    }
+    interface LiteralExpression extends PrimaryExpression {
+        text: string;
+        isUnterminated?: boolean;
+    }
+    interface StringLiteralExpression extends LiteralExpression {
+        _stringLiteralExpressionBrand: any;
+    }
+    interface TemplateExpression extends PrimaryExpression {
+        head: LiteralExpression;
+        templateSpans: NodeArray<TemplateSpan>;
+    }
+    interface TemplateSpan extends Node {
+        expression: Expression;
+        literal: LiteralExpression;
+    }
+    interface ParenthesizedExpression extends PrimaryExpression {
+        expression: Expression;
+    }
+    interface ArrayLiteralExpression extends PrimaryExpression {
+        elements: NodeArray<Expression>;
+    }
+    interface ObjectLiteralExpression extends PrimaryExpression, Declaration {
+        properties: NodeArray<ObjectLiteralElement>;
+    }
+    interface PropertyAccessExpression extends MemberExpression {
+        expression: LeftHandSideExpression;
+        name: Identifier;
+    }
+    interface ElementAccessExpression extends MemberExpression {
+        expression: LeftHandSideExpression;
+        argumentExpression?: Expression;
+    }
+    interface CallExpression extends LeftHandSideExpression {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+        arguments: NodeArray<Expression>;
+    }
+    interface NewExpression extends CallExpression, PrimaryExpression {
+    }
+    interface TaggedTemplateExpression extends MemberExpression {
+        tag: LeftHandSideExpression;
+        template: LiteralExpression | TemplateExpression;
+    }
+    type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;
+    interface TypeAssertion extends UnaryExpression {
+        type: TypeNode;
+        expression: UnaryExpression;
+    }
+    interface Statement extends Node, ModuleElement {
+        _statementBrand: any;
+    }
+    interface Block extends Statement {
+        statements: NodeArray<Statement>;
+    }
+    interface VariableStatement extends Statement {
+        declarations: NodeArray<VariableDeclaration>;
+    }
+    interface ExpressionStatement extends Statement {
+        expression: Expression;
+    }
+    interface IfStatement extends Statement {
+        expression: Expression;
+        thenStatement: Statement;
+        elseStatement?: Statement;
+    }
+    interface IterationStatement extends Statement {
+        statement: Statement;
+    }
+    interface DoStatement extends IterationStatement {
+        expression: Expression;
+    }
+    interface WhileStatement extends IterationStatement {
+        expression: Expression;
+    }
+    interface ForStatement extends IterationStatement {
+        declarations?: NodeArray<VariableDeclaration>;
+        initializer?: Expression;
+        condition?: Expression;
+        iterator?: Expression;
+    }
+    interface ForInStatement extends IterationStatement {
+        declarations?: NodeArray<VariableDeclaration>;
+        variable?: Expression;
+        expression: Expression;
+    }
+    interface BreakOrContinueStatement extends Statement {
+        label?: Identifier;
+    }
+    interface ReturnStatement extends Statement {
+        expression?: Expression;
+    }
+    interface WithStatement extends Statement {
+        expression: Expression;
+        statement: Statement;
+    }
+    interface SwitchStatement extends Statement {
+        expression: Expression;
+        clauses: NodeArray<CaseOrDefaultClause>;
+    }
+    interface CaseClause extends Node {
+        expression?: Expression;
+        statements: NodeArray<Statement>;
+    }
+    interface DefaultClause extends Node {
+        statements: NodeArray<Statement>;
+    }
+    type CaseOrDefaultClause = CaseClause | DefaultClause;
+    interface LabeledStatement extends Statement {
+        label: Identifier;
+        statement: Statement;
+    }
+    interface ThrowStatement extends Statement {
+        expression: Expression;
+    }
+    interface TryStatement extends Statement {
+        tryBlock: Block;
+        catchClause?: CatchClause;
+        finallyBlock?: Block;
+    }
+    interface CatchClause extends Declaration {
+        name: Identifier;
+        type?: TypeNode;
+        block: Block;
+    }
+    interface ModuleElement extends Node {
+        _moduleElementBrand: any;
+    }
+    interface ClassDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        heritageClauses?: NodeArray<HeritageClause>;
+        members: NodeArray<ClassElement>;
+    }
+    interface ClassElement extends Declaration {
+        _classElementBrand: any;
+    }
+    interface InterfaceDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        heritageClauses?: NodeArray<HeritageClause>;
+        members: NodeArray<Declaration>;
+    }
+    interface HeritageClause extends Node {
+        token: SyntaxKind;
+        types?: NodeArray<TypeReferenceNode>;
+    }
+    interface TypeAliasDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        type: TypeNode;
+    }
+    interface EnumMember extends Declaration {
+        name: DeclarationName;
+        initializer?: Expression;
+    }
+    interface EnumDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        members: NodeArray<EnumMember>;
+    }
+    interface ModuleDeclaration extends Declaration, ModuleElement {
+        name: Identifier | LiteralExpression;
+        body: ModuleBlock | ModuleDeclaration;
+    }
+    interface ModuleBlock extends Node, ModuleElement {
+        statements: NodeArray<ModuleElement>;
+    }
+    interface ImportDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        moduleReference: EntityName | ExternalModuleReference;
+    }
+    interface ExternalModuleReference extends Node {
+        expression?: Expression;
+    }
+    interface ExportAssignment extends Statement, ModuleElement {
+        exportName: Identifier;
+    }
+    interface FileReference extends TextRange {
+        filename: string;
+    }
+    interface CommentRange extends TextRange {
+        hasTrailingNewLine?: boolean;
+    }
+    interface SourceFile extends Declaration {
+        statements: NodeArray<ModuleElement>;
+        endOfFileToken: Node;
+        filename: string;
+        text: string;
+        getLineAndCharacterFromPosition(position: number): LineAndCharacter;
+        getPositionFromLineAndCharacter(line: number, character: number): number;
+        getLineStarts(): number[];
+        amdDependencies: string[];
+        amdModuleName: string;
+        referencedFiles: FileReference[];
+        referenceDiagnostics: Diagnostic[];
+        parseDiagnostics: Diagnostic[];
+        grammarDiagnostics: Diagnostic[];
+        getSyntacticDiagnostics(): Diagnostic[];
+        semanticDiagnostics: Diagnostic[];
+        hasNoDefaultLib: boolean;
+        externalModuleIndicator: Node;
+        nodeCount: number;
+        identifierCount: number;
+        symbolCount: number;
+        isOpen: boolean;
+        version: string;
+        languageVersion: ScriptTarget;
+        identifiers: Map<string>;
+    }
+    interface Program {
+        getSourceFile(filename: string): SourceFile;
+        getSourceFiles(): SourceFile[];
+        getCompilerOptions(): CompilerOptions;
+        getCompilerHost(): CompilerHost;
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];
+        getGlobalDiagnostics(): Diagnostic[];
+        getTypeChecker(fullTypeCheckMode: boolean): TypeChecker;
+        getCommonSourceDirectory(): string;
+    }
+    interface SourceMapSpan {
+        emittedLine: number;
+        emittedColumn: number;
+        sourceLine: number;
+        sourceColumn: number;
+        nameIndex?: number;
+        sourceIndex: number;
+    }
+    interface SourceMapData {
+        sourceMapFilePath: string;
+        jsSourceMappingURL: string;
+        sourceMapFile: string;
+        sourceMapSourceRoot: string;
+        sourceMapSources: string[];
+        inputSourceFileNames: string[];
+        sourceMapNames?: string[];
+        sourceMapMappings: string;
+        sourceMapDecodedMappings: SourceMapSpan[];
+    }
+    enum EmitReturnStatus {
+        Succeeded = 0,
+        AllOutputGenerationSkipped = 1,
+        JSGeneratedWithSemanticErrors = 2,
+        DeclarationGenerationSkipped = 3,
+        EmitErrorsEncountered = 4,
+        CompilerOptionsErrors = 5,
+    }
+    interface EmitResult {
+        emitResultStatus: EmitReturnStatus;
+        diagnostics: Diagnostic[];
+        sourceMaps: SourceMapData[];
+    }
+    interface TypeChecker {
+        getProgram(): Program;
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];
+        getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[];
+        getGlobalDiagnostics(): Diagnostic[];
+        getNodeCount(): number;
+        getIdentifierCount(): number;
+        getSymbolCount(): number;
+        getTypeCount(): number;
+        emitFiles(targetSourceFile?: SourceFile): EmitResult;
+        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
+        getDeclaredTypeOfSymbol(symbol: Symbol): Type;
+        getPropertiesOfType(type: Type): Symbol[];
+        getPropertyOfType(type: Type, propertyName: string): Symbol;
+        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
+        getIndexTypeOfType(type: Type, kind: IndexKind): Type;
+        getReturnTypeOfSignature(signature: Signature): Type;
+        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
+        getSymbolAtLocation(node: Node): Symbol;
+        getShorthandAssignmentValueSymbol(location: Node): Symbol;
+        getTypeAtLocation(node: Node): Type;
+        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        getSymbolDisplayBuilder(): SymbolDisplayBuilder;
+        getFullyQualifiedName(symbol: Symbol): string;
+        getAugmentedPropertiesOfType(type: Type): Symbol[];
+        getRootSymbols(symbol: Symbol): Symbol[];
+        getContextualType(node: Expression): Type;
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        isUndefinedSymbol(symbol: Symbol): boolean;
+        isArgumentsSymbol(symbol: Symbol): boolean;
+        isEmitBlocked(sourceFile?: SourceFile): boolean;
+        getEnumMemberValue(node: EnumMember): number;
+        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
+        getAliasedSymbol(symbol: Symbol): Symbol;
+    }
+    interface SymbolDisplayBuilder {
+        buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
+        buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+    }
+    interface SymbolWriter {
+        writeKeyword(text: string): void;
+        writeOperator(text: string): void;
+        writePunctuation(text: string): void;
+        writeSpace(text: string): void;
+        writeStringLiteral(text: string): void;
+        writeParameter(text: string): void;
+        writeSymbol(text: string, symbol: Symbol): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        clear(): void;
+        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+    }
+    const enum TypeFormatFlags {
+        None = 0,
+        WriteArrayAsGenericType = 1,
+        UseTypeOfFunction = 2,
+        NoTruncation = 4,
+        WriteArrowStyleSignature = 8,
+        WriteOwnNameForAnyLike = 16,
+        WriteTypeArgumentsOfSignature = 32,
+        InElementType = 64,
+    }
+    const enum SymbolFormatFlags {
+        None = 0,
+        WriteTypeParametersOrArguments = 1,
+        UseOnlyExternalAliasing = 2,
+    }
+    const enum SymbolAccessibility {
+        Accessible = 0,
+        NotAccessible = 1,
+        CannotBeNamed = 2,
+    }
+    interface SymbolVisibilityResult {
+        accessibility: SymbolAccessibility;
+        aliasesToMakeVisible?: ImportDeclaration[];
+        errorSymbolName?: string;
+        errorNode?: Node;
+    }
+    interface SymbolAccessiblityResult extends SymbolVisibilityResult {
+        errorModuleName?: string;
+    }
+    interface EmitResolver {
+        getProgram(): Program;
+        getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string;
+        getExpressionNamePrefix(node: Identifier): string;
+        getExportAssignmentName(node: SourceFile): string;
+        isReferencedImportDeclaration(node: ImportDeclaration): boolean;
+        isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean;
+        getNodeCheckFlags(node: Node): NodeCheckFlags;
+        getEnumMemberValue(node: EnumMember): number;
+        hasSemanticErrors(sourceFile?: SourceFile): boolean;
+        isDeclarationVisible(node: Declaration): boolean;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
+        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number;
+        isEmitBlocked(sourceFile?: SourceFile): boolean;
+    }
+    const enum SymbolFlags {
+        FunctionScopedVariable = 1,
+        BlockScopedVariable = 2,
+        Property = 4,
+        EnumMember = 8,
+        Function = 16,
+        Class = 32,
+        Interface = 64,
+        ConstEnum = 128,
+        RegularEnum = 256,
+        ValueModule = 512,
+        NamespaceModule = 1024,
+        TypeLiteral = 2048,
+        ObjectLiteral = 4096,
+        Method = 8192,
+        Constructor = 16384,
+        GetAccessor = 32768,
+        SetAccessor = 65536,
+        CallSignature = 131072,
+        ConstructSignature = 262144,
+        IndexSignature = 524288,
+        TypeParameter = 1048576,
+        TypeAlias = 2097152,
+        ExportValue = 4194304,
+        ExportType = 8388608,
+        ExportNamespace = 16777216,
+        Import = 33554432,
+        Instantiated = 67108864,
+        Merged = 134217728,
+        Transient = 268435456,
+        Prototype = 536870912,
+        UnionProperty = 1073741824,
+        Enum = 384,
+        Variable = 3,
+        Value = 107455,
+        Type = 3152352,
+        Namespace = 1536,
+        Module = 1536,
+        Accessor = 98304,
+        Signature = 917504,
+        FunctionScopedVariableExcludes = 107454,
+        BlockScopedVariableExcludes = 107455,
+        ParameterExcludes = 107455,
+        PropertyExcludes = 107455,
+        EnumMemberExcludes = 107455,
+        FunctionExcludes = 106927,
+        ClassExcludes = 3258879,
+        InterfaceExcludes = 3152288,
+        RegularEnumExcludes = 3258623,
+        ConstEnumExcludes = 3259263,
+        ValueModuleExcludes = 106639,
+        NamespaceModuleExcludes = 0,
+        MethodExcludes = 99263,
+        GetAccessorExcludes = 41919,
+        SetAccessorExcludes = 74687,
+        TypeParameterExcludes = 2103776,
+        TypeAliasExcludes = 3152352,
+        ImportExcludes = 33554432,
+        ModuleMember = 35653619,
+        ExportHasLocal = 944,
+        HasLocals = 1041936,
+        HasExports = 1952,
+        HasMembers = 6240,
+        IsContainer = 1048560,
+        PropertyOrAccessor = 98308,
+        Export = 29360128,
+    }
+    interface Symbol {
+        flags: SymbolFlags;
+        name: string;
+        id?: number;
+        mergeId?: number;
+        declarations?: Declaration[];
+        parent?: Symbol;
+        members?: SymbolTable;
+        exports?: SymbolTable;
+        exportSymbol?: Symbol;
+        valueDeclaration?: Declaration;
+        constEnumOnlyModule?: boolean;
+    }
+    interface SymbolLinks {
+        target?: Symbol;
+        type?: Type;
+        declaredType?: Type;
+        mapper?: TypeMapper;
+        referenced?: boolean;
+        exportAssignSymbol?: Symbol;
+        unionType?: UnionType;
+    }
+    interface TransientSymbol extends Symbol, SymbolLinks {
+    }
+    interface SymbolTable {
+        [index: string]: Symbol;
+    }
+    const enum NodeCheckFlags {
+        TypeChecked = 1,
+        LexicalThis = 2,
+        CaptureThis = 4,
+        EmitExtends = 8,
+        SuperInstance = 16,
+        SuperStatic = 32,
+        ContextChecked = 64,
+        EnumValuesComputed = 128,
+    }
+    interface NodeLinks {
+        resolvedType?: Type;
+        resolvedSignature?: Signature;
+        resolvedSymbol?: Symbol;
+        flags?: NodeCheckFlags;
+        enumMemberValue?: number;
+        isIllegalTypeReferenceInConstraint?: boolean;
+        isVisible?: boolean;
+        localModuleName?: string;
+        assignmentChecks?: Map<boolean>;
+    }
+    const enum TypeFlags {
+        Any = 1,
+        String = 2,
+        Number = 4,
+        Boolean = 8,
+        Void = 16,
+        Undefined = 32,
+        Null = 64,
+        Enum = 128,
+        StringLiteral = 256,
+        TypeParameter = 512,
+        Class = 1024,
+        Interface = 2048,
+        Reference = 4096,
+        Tuple = 8192,
+        Union = 16384,
+        Anonymous = 32768,
+        FromSignature = 65536,
+        Intrinsic = 127,
+        StringLike = 258,
+        NumberLike = 132,
+        ObjectType = 48128,
+    }
+    interface Type {
+        flags: TypeFlags;
+        id: number;
+        symbol?: Symbol;
+    }
+    interface IntrinsicType extends Type {
+        intrinsicName: string;
+    }
+    interface StringLiteralType extends Type {
+        text: string;
+    }
+    interface ObjectType extends Type {
+    }
+    interface InterfaceType extends ObjectType {
+        typeParameters: TypeParameter[];
+        baseTypes: ObjectType[];
+        declaredProperties: Symbol[];
+        declaredCallSignatures: Signature[];
+        declaredConstructSignatures: Signature[];
+        declaredStringIndexType: Type;
+        declaredNumberIndexType: Type;
+    }
+    interface TypeReference extends ObjectType {
+        target: GenericType;
+        typeArguments: Type[];
+    }
+    interface GenericType extends InterfaceType, TypeReference {
+        instantiations: Map<TypeReference>;
+        openReferenceTargets: GenericType[];
+        openReferenceChecks: Map<boolean>;
+    }
+    interface TupleType extends ObjectType {
+        elementTypes: Type[];
+        baseArrayType: TypeReference;
+    }
+    interface UnionType extends Type {
+        types: Type[];
+        resolvedProperties: SymbolTable;
+    }
+    interface ResolvedType extends ObjectType, UnionType {
+        members: SymbolTable;
+        properties: Symbol[];
+        callSignatures: Signature[];
+        constructSignatures: Signature[];
+        stringIndexType: Type;
+        numberIndexType: Type;
+    }
+    interface TypeParameter extends Type {
+        constraint: Type;
+        target?: TypeParameter;
+        mapper?: TypeMapper;
+    }
+    const enum SignatureKind {
+        Call = 0,
+        Construct = 1,
+    }
+    interface Signature {
+        declaration: SignatureDeclaration;
+        typeParameters: TypeParameter[];
+        parameters: Symbol[];
+        resolvedReturnType: Type;
+        minArgumentCount: number;
+        hasRestParameter: boolean;
+        hasStringLiterals: boolean;
+        target?: Signature;
+        mapper?: TypeMapper;
+        unionSignatures?: Signature[];
+        erasedSignatureCache?: Signature;
+        isolatedSignatureType?: ObjectType;
+    }
+    const enum IndexKind {
+        String = 0,
+        Number = 1,
+    }
+    interface TypeMapper {
+        (t: Type): Type;
+    }
+    interface TypeInferences {
+        primary: Type[];
+        secondary: Type[];
+    }
+    interface InferenceContext {
+        typeParameters: TypeParameter[];
+        inferUnionTypes: boolean;
+        inferences: TypeInferences[];
+        inferredTypes: Type[];
+        failedTypeParameterIndex?: number;
+    }
+    interface DiagnosticMessage {
+        key: string;
+        category: DiagnosticCategory;
+        code: number;
+        isEarly?: boolean;
+    }
+    interface DiagnosticMessageChain {
+        messageText: string;
+        category: DiagnosticCategory;
+        code: number;
+        next?: DiagnosticMessageChain;
+    }
+    interface Diagnostic {
+        file: SourceFile;
+        start: number;
+        length: number;
+        messageText: string;
+        category: DiagnosticCategory;
+        code: number;
+        /**
+          * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit
+          */
+        isEarly?: boolean;
+    }
+    enum DiagnosticCategory {
+        Warning = 0,
+        Error = 1,
+        Message = 2,
+    }
+    interface CompilerOptions {
+        allowNonTsExtensions?: boolean;
+        charset?: string;
+        codepage?: number;
+        declaration?: boolean;
+        diagnostics?: boolean;
+        emitBOM?: boolean;
+        help?: boolean;
+        locale?: string;
+        mapRoot?: string;
+        module?: ModuleKind;
+        noEmitOnError?: boolean;
+        noErrorTruncation?: boolean;
+        noImplicitAny?: boolean;
+        noLib?: boolean;
+        noLibCheck?: boolean;
+        noResolve?: boolean;
+        out?: string;
+        outDir?: string;
+        preserveConstEnums?: boolean;
+        removeComments?: boolean;
+        sourceMap?: boolean;
+        sourceRoot?: string;
+        suppressImplicitAnyIndexErrors?: boolean;
+        target?: ScriptTarget;
+        version?: boolean;
+        watch?: boolean;
+        [option: string]: string | number | boolean;
+    }
+    const enum ModuleKind {
+        None = 0,
+        CommonJS = 1,
+        AMD = 2,
+    }
+    interface LineAndCharacter {
+        line: number;
+        character: number;
+    }
+    const enum ScriptTarget {
+        ES3 = 0,
+        ES5 = 1,
+        ES6 = 2,
+        Latest = 2,
+    }
+    interface ParsedCommandLine {
+        options: CompilerOptions;
+        filenames: string[];
+        errors: Diagnostic[];
+    }
+    interface CommandLineOption {
+        name: string;
+        type: string | Map<number>;
+        shortName?: string;
+        description?: DiagnosticMessage;
+        paramType?: DiagnosticMessage;
+        error?: DiagnosticMessage;
+    }
+    const enum CharacterCodes {
+        nullCharacter = 0,
+        maxAsciiCharacter = 127,
+        lineFeed = 10,
+        carriageReturn = 13,
+        lineSeparator = 8232,
+        paragraphSeparator = 8233,
+        nextLine = 133,
+        space = 32,
+        nonBreakingSpace = 160,
+        enQuad = 8192,
+        emQuad = 8193,
+        enSpace = 8194,
+        emSpace = 8195,
+        threePerEmSpace = 8196,
+        fourPerEmSpace = 8197,
+        sixPerEmSpace = 8198,
+        figureSpace = 8199,
+        punctuationSpace = 8200,
+        thinSpace = 8201,
+        hairSpace = 8202,
+        zeroWidthSpace = 8203,
+        narrowNoBreakSpace = 8239,
+        ideographicSpace = 12288,
+        mathematicalSpace = 8287,
+        ogham = 5760,
+        _ = 95,
+        $ = 36,
+        _0 = 48,
+        _1 = 49,
+        _2 = 50,
+        _3 = 51,
+        _4 = 52,
+        _5 = 53,
+        _6 = 54,
+        _7 = 55,
+        _8 = 56,
+        _9 = 57,
+        a = 97,
+        b = 98,
+        c = 99,
+        d = 100,
+        e = 101,
+        f = 102,
+        g = 103,
+        h = 104,
+        i = 105,
+        j = 106,
+        k = 107,
+        l = 108,
+        m = 109,
+        n = 110,
+        o = 111,
+        p = 112,
+        q = 113,
+        r = 114,
+        s = 115,
+        t = 116,
+        u = 117,
+        v = 118,
+        w = 119,
+        x = 120,
+        y = 121,
+        z = 122,
+        A = 65,
+        B = 66,
+        C = 67,
+        D = 68,
+        E = 69,
+        F = 70,
+        G = 71,
+        H = 72,
+        I = 73,
+        J = 74,
+        K = 75,
+        L = 76,
+        M = 77,
+        N = 78,
+        O = 79,
+        P = 80,
+        Q = 81,
+        R = 82,
+        S = 83,
+        T = 84,
+        U = 85,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+        ampersand = 38,
+        asterisk = 42,
+        at = 64,
+        backslash = 92,
+        backtick = 96,
+        bar = 124,
+        caret = 94,
+        closeBrace = 125,
+        closeBracket = 93,
+        closeParen = 41,
+        colon = 58,
+        comma = 44,
+        dot = 46,
+        doubleQuote = 34,
+        equals = 61,
+        exclamation = 33,
+        greaterThan = 62,
+        lessThan = 60,
+        minus = 45,
+        openBrace = 123,
+        openBracket = 91,
+        openParen = 40,
+        percent = 37,
+        plus = 43,
+        question = 63,
+        semicolon = 59,
+        singleQuote = 39,
+        slash = 47,
+        tilde = 126,
+        backspace = 8,
+        formFeed = 12,
+        byteOrderMark = 65279,
+        tab = 9,
+        verticalTab = 11,
+    }
+    interface CancellationToken {
+        isCancellationRequested(): boolean;
+    }
+    interface CompilerHost {
+        getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
+        getDefaultLibFilename(options: CompilerOptions): string;
+        getCancellationToken?(): CancellationToken;
+        writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void;
+        getCurrentDirectory(): string;
+        getCanonicalFileName(fileName: string): string;
+        useCaseSensitiveFileNames(): boolean;
+        getNewLine(): string;
+    }
+}
+declare module "typescript" {
+    interface ErrorCallback {
+        (message: DiagnosticMessage): void;
+    }
+    interface CommentCallback {
+        (pos: number, end: number): void;
+    }
+    interface Scanner {
+        getStartPos(): number;
+        getToken(): SyntaxKind;
+        getTextPos(): number;
+        getTokenPos(): number;
+        getTokenText(): string;
+        getTokenValue(): string;
+        hasPrecedingLineBreak(): boolean;
+        isIdentifier(): boolean;
+        isReservedWord(): boolean;
+        isUnterminated(): boolean;
+        reScanGreaterToken(): SyntaxKind;
+        reScanSlashToken(): SyntaxKind;
+        reScanTemplateToken(): SyntaxKind;
+        scan(): SyntaxKind;
+        setText(text: string): void;
+        setTextPos(textPos: number): void;
+        lookAhead<T>(callback: () => T): T;
+        tryScan<T>(callback: () => T): T;
+    }
+    function tokenToString(t: SyntaxKind): string;
+    function computeLineStarts(text: string): number[];
+    function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number;
+    function getLineAndCharacterOfPosition(lineStarts: number[], position: number): {
+        line: number;
+        character: number;
+    };
+    function positionToLineAndCharacter(text: string, pos: number): {
+        line: number;
+        character: number;
+    };
+    function isWhiteSpace(ch: number): boolean;
+    function isLineBreak(ch: number): boolean;
+    function isOctalDigit(ch: number): boolean;
+    function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number;
+    function getLeadingCommentRanges(text: string, pos: number): CommentRange[];
+    function getTrailingCommentRanges(text: string, pos: number): CommentRange[];
+    function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;
+    function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;
+    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner;
+}
+declare module "typescript" {
+    function getNodeConstructor(kind: SyntaxKind): new () => Node;
+    function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T;
+    function createCompilerHost(options: CompilerOptions): CompilerHost;
+    function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile;
+    function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program;
+}
+declare module "typescript" {
+    function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker;
+}
+declare module "typescript" {
+    var servicesVersion: string;
+    interface Node {
+        getSourceFile(): SourceFile;
+        getChildCount(sourceFile?: SourceFile): number;
+        getChildAt(index: number, sourceFile?: SourceFile): Node;
+        getChildren(sourceFile?: SourceFile): Node[];
+        getStart(sourceFile?: SourceFile): number;
+        getFullStart(): number;
+        getEnd(): number;
+        getWidth(sourceFile?: SourceFile): number;
+        getFullWidth(): number;
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
+        getFullText(sourceFile?: SourceFile): string;
+        getText(sourceFile?: SourceFile): string;
+        getFirstToken(sourceFile?: SourceFile): Node;
+        getLastToken(sourceFile?: SourceFile): Node;
+    }
+    interface Symbol {
+        getFlags(): SymbolFlags;
+        getName(): string;
+        getDeclarations(): Declaration[];
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+    interface Type {
+        getFlags(): TypeFlags;
+        getSymbol(): Symbol;
+        getProperties(): Symbol[];
+        getProperty(propertyName: string): Symbol;
+        getApparentProperties(): Symbol[];
+        getCallSignatures(): Signature[];
+        getConstructSignatures(): Signature[];
+        getStringIndexType(): Type;
+        getNumberIndexType(): Type;
+    }
+    interface Signature {
+        getDeclaration(): SignatureDeclaration;
+        getTypeParameters(): Type[];
+        getParameters(): Symbol[];
+        getReturnType(): Type;
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+    interface SourceFile {
+        getScriptSnapshot(): IScriptSnapshot;
+        getNamedDeclarations(): Declaration[];
+        update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;
+    }
+    /**
+     * Represents an immutable snapshot of a script at a specified time.Once acquired, the
+     * snapshot is observably immutable. i.e. the same calls with the same parameters will return
+     * the same values.
+     */
+    interface IScriptSnapshot {
+        /** Gets a portion of the script snapshot specified by [start, end). */
+        getText(start: number, end: number): string;
+        /** Gets the length of this script snapshot. */
+        getLength(): number;
+        /**
+         * This call returns the array containing the start position of every line.
+         * i.e."[0, 10, 55]".  TODO: consider making this optional.  The language service could
+         * always determine this (albeit in a more expensive manner).
+         */
+        getLineStartPositions(): number[];
+        /**
+         * Gets the TextChangeRange that describe how the text changed between this text and
+         * an older version.  This information is used by the incremental parser to determine
+         * what sections of the script need to be re-parsed.  'undefined' can be returned if the
+         * change range cannot be determined.  However, in that case, incremental parsing will
+         * not happen and the entire document will be re - parsed.
+         */
+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;
+    }
+    module ScriptSnapshot {
+        function fromString(text: string): IScriptSnapshot;
+    }
+    interface PreProcessedFileInfo {
+        referencedFiles: FileReference[];
+        importedFiles: FileReference[];
+        isLibFile: boolean;
+    }
+    interface Logger {
+        log(s: string): void;
+    }
+    interface LanguageServiceHost extends Logger {
+        getCompilationSettings(): CompilerOptions;
+        getScriptFileNames(): string[];
+        getScriptVersion(fileName: string): string;
+        getScriptIsOpen(fileName: string): boolean;
+        getScriptSnapshot(fileName: string): IScriptSnapshot;
+        getLocalizedDiagnosticMessages?(): any;
+        getCancellationToken?(): CancellationToken;
+        getCurrentDirectory(): string;
+        getDefaultLibFilename(options: CompilerOptions): string;
+    }
+    interface LanguageService {
+        cleanupSemanticCache(): void;
+        getSyntacticDiagnostics(fileName: string): Diagnostic[];
+        getSemanticDiagnostics(fileName: string): Diagnostic[];
+        getCompilerOptionsDiagnostics(): Diagnostic[];
+        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
+        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
+        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;
+        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;
+        getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;
+        getRenameInfo(fileName: string, position: number): RenameInfo;
+        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
+        getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        getNavigateToItems(searchValue: string): NavigateToItem[];
+        getNavigationBarItems(fileName: string): NavigationBarItem[];
+        getOutliningSpans(fileName: string): OutliningSpan[];
+        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
+        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number;
+        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[];
+        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[];
+        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[];
+        getEmitOutput(fileName: string): EmitOutput;
+        getSourceFile(filename: string): SourceFile;
+        dispose(): void;
+    }
+    class TextSpan {
+        private _start;
+        private _length;
+        /**
+            * Creates a TextSpan instance beginning with the position Start and having the Length
+            * specified with length.
+            */
+        constructor(start: number, length: number);
+        toJSON(key: any): any;
+        start(): number;
+        length(): number;
+        end(): number;
+        isEmpty(): boolean;
+        /**
+            * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less
+            * than End, otherwise false.
+            * @param position The position to check.
+            */
+        containsPosition(position: number): boolean;
+        /**
+            * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.
+            * @param span The span to check.
+            */
+        containsTextSpan(span: TextSpan): boolean;
+        /**
+            * Determines whether the given span overlaps this span. Two spans are considered to overlap
+            * if they have positions in common and neither is empty. Empty spans do not overlap with any
+            * other span. Returns true if the spans overlap, false otherwise.
+            * @param span The span to check.
+            */
+        overlapsWith(span: TextSpan): boolean;
+        /**
+            * Returns the overlap with the given span, or undefined if there is no overlap.
+            * @param span The span to check.
+            */
+        overlap(span: TextSpan): TextSpan;
+        /**
+            * Determines whether span intersects this span. Two spans are considered to
+            * intersect if they have positions in common or the end of one span
+            * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.
+            * @param The span to check.
+            */
+        intersectsWithTextSpan(span: TextSpan): boolean;
+        intersectsWith(start: number, length: number): boolean;
+        /**
+            * Determines whether the given position intersects this span.
+            * A position is considered to intersect if it is between the start and
+            * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.
+            * @param position The position to check.
+            */
+        intersectsWithPosition(position: number): boolean;
+        /**
+            * Returns the intersection with the given span, or undefined if there is no intersection.
+            * @param span The span to check.
+            */
+        intersection(span: TextSpan): TextSpan;
+        /**
+            * Creates a new TextSpan from the given start and end positions
+            * as opposed to a position and length.
+            */
+        static fromBounds(start: number, end: number): TextSpan;
+    }
+    class TextChangeRange {
+        static unchanged: TextChangeRange;
+        private _span;
+        private _newLength;
+        /**
+            * Initializes a new instance of TextChangeRange.
+            */
+        constructor(span: TextSpan, newLength: number);
+        /**
+            * The span of text before the edit which is being changed
+            */
+        span(): TextSpan;
+        /**
+            * Width of the span after the edit.  A 0 here would represent a delete
+            */
+        newLength(): number;
+        newSpan(): TextSpan;
+        isUnchanged(): boolean;
+        /**
+            * Called to merge all the changes that occurred across several versions of a script snapshot
+            * into a single change.  i.e. if a user keeps making successive edits to a script we will
+            * have a text change from V1 to V2, V2 to V3, ..., Vn.
+            *
+            * This function will then merge those changes into a single change range valid between V1 and
+            * Vn.
+            */
+        static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
+    }
+    interface ClassifiedSpan {
+        textSpan: TextSpan;
+        classificationType: string;
+    }
+    interface NavigationBarItem {
+        text: string;
+        kind: string;
+        kindModifiers: string;
+        spans: TextSpan[];
+        childItems: NavigationBarItem[];
+        indent: number;
+        bolded: boolean;
+        grayed: boolean;
+    }
+    interface TodoCommentDescriptor {
+        text: string;
+        priority: number;
+    }
+    interface TodoComment {
+        descriptor: TodoCommentDescriptor;
+        message: string;
+        position: number;
+    }
+    class TextChange {
+        span: TextSpan;
+        newText: string;
+    }
+    interface RenameLocation {
+        textSpan: TextSpan;
+        fileName: string;
+    }
+    interface ReferenceEntry {
+        textSpan: TextSpan;
+        fileName: string;
+        isWriteAccess: boolean;
+    }
+    interface NavigateToItem {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+        matchKind: string;
+        fileName: string;
+        textSpan: TextSpan;
+        containerName: string;
+        containerKind: string;
+    }
+    interface EditorOptions {
+        IndentSize: number;
+        TabSize: number;
+        NewLineCharacter: string;
+        ConvertTabsToSpaces: boolean;
+    }
+    interface FormatCodeOptions extends EditorOptions {
+        InsertSpaceAfterCommaDelimiter: boolean;
+        InsertSpaceAfterSemicolonInForStatements: boolean;
+        InsertSpaceBeforeAndAfterBinaryOperators: boolean;
+        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
+        PlaceOpenBraceOnNewLineForFunctions: boolean;
+        PlaceOpenBraceOnNewLineForControlBlocks: boolean;
+    }
+    interface DefinitionInfo {
+        fileName: string;
+        textSpan: TextSpan;
+        kind: string;
+        name: string;
+        containerKind: string;
+        containerName: string;
+    }
+    enum SymbolDisplayPartKind {
+        aliasName = 0,
+        className = 1,
+        enumName = 2,
+        fieldName = 3,
+        interfaceName = 4,
+        keyword = 5,
+        lineBreak = 6,
+        numericLiteral = 7,
+        stringLiteral = 8,
+        localName = 9,
+        methodName = 10,
+        moduleName = 11,
+        operator = 12,
+        parameterName = 13,
+        propertyName = 14,
+        punctuation = 15,
+        space = 16,
+        text = 17,
+        typeParameterName = 18,
+        enumMemberName = 19,
+        functionName = 20,
+        regularExpressionLiteral = 21,
+    }
+    interface SymbolDisplayPart {
+        text: string;
+        kind: string;
+    }
+    interface QuickInfo {
+        kind: string;
+        kindModifiers: string;
+        textSpan: TextSpan;
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+    interface RenameInfo {
+        canRename: boolean;
+        localizedErrorMessage: string;
+        displayName: string;
+        fullDisplayName: string;
+        kind: string;
+        kindModifiers: string;
+        triggerSpan: TextSpan;
+    }
+    interface SignatureHelpParameter {
+        name: string;
+        documentation: SymbolDisplayPart[];
+        displayParts: SymbolDisplayPart[];
+        isOptional: boolean;
+    }
+    /**
+     * Represents a single signature to show in signature help.
+     * The id is used for subsequent calls into the language service to ask questions about the
+     * signature help item in the context of any documents that have been updated.  i.e. after
+     * an edit has happened, while signature help is still active, the host can ask important
+     * questions like 'what parameter is the user currently contained within?'.
+     */
+    interface SignatureHelpItem {
+        isVariadic: boolean;
+        prefixDisplayParts: SymbolDisplayPart[];
+        suffixDisplayParts: SymbolDisplayPart[];
+        separatorDisplayParts: SymbolDisplayPart[];
+        parameters: SignatureHelpParameter[];
+        documentation: SymbolDisplayPart[];
+    }
+    /**
+     * Represents a set of signature help items, and the preferred item that should be selected.
+     */
+    interface SignatureHelpItems {
+        items: SignatureHelpItem[];
+        applicableSpan: TextSpan;
+        selectedItemIndex: number;
+        argumentIndex: number;
+        argumentCount: number;
+    }
+    interface CompletionInfo {
+        isMemberCompletion: boolean;
+        entries: CompletionEntry[];
+    }
+    interface CompletionEntry {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+    }
+    interface CompletionEntryDetails {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+    interface OutliningSpan {
+        /** The span of the document to actually collapse. */
+        textSpan: TextSpan;
+        /** The span of the document to display when the user hovers over the collapsed span. */
+        hintSpan: TextSpan;
+        /** The text to display in the editor for the collapsed region. */
+        bannerText: string;
+        /**
+          * Whether or not this region should be automatically collapsed when
+          * the 'Collapse to Definitions' command is invoked.
+          */
+        autoCollapse: boolean;
+    }
+    interface EmitOutput {
+        outputFiles: OutputFile[];
+        emitOutputStatus: EmitReturnStatus;
+    }
+    const enum OutputFileType {
+        JavaScript = 0,
+        SourceMap = 1,
+        Declaration = 2,
+    }
+    interface OutputFile {
+        name: string;
+        writeByteOrderMark: boolean;
+        text: string;
+    }
+    const enum EndOfLineState {
+        Start = 0,
+        InMultiLineCommentTrivia = 1,
+        InSingleQuoteStringLiteral = 2,
+        InDoubleQuoteStringLiteral = 3,
+    }
+    enum TokenClass {
+        Punctuation = 0,
+        Keyword = 1,
+        Operator = 2,
+        Comment = 3,
+        Whitespace = 4,
+        Identifier = 5,
+        NumberLiteral = 6,
+        StringLiteral = 7,
+        RegExpLiteral = 8,
+    }
+    interface ClassificationResult {
+        finalLexState: EndOfLineState;
+        entries: ClassificationInfo[];
+    }
+    interface ClassificationInfo {
+        length: number;
+        classification: TokenClass;
+    }
+    interface Classifier {
+        getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult;
+    }
+    interface DocumentRegistry {
+        acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile;
+        updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;
+        releaseDocument(filename: string, compilationSettings: CompilerOptions): void;
+    }
+    class ScriptElementKind {
+        static unknown: string;
+        static keyword: string;
+        static scriptElement: string;
+        static moduleElement: string;
+        static classElement: string;
+        static interfaceElement: string;
+        static typeElement: string;
+        static enumElement: string;
+        static variableElement: string;
+        static localVariableElement: string;
+        static functionElement: string;
+        static localFunctionElement: string;
+        static memberFunctionElement: string;
+        static memberGetAccessorElement: string;
+        static memberSetAccessorElement: string;
+        static memberVariableElement: string;
+        static constructorImplementationElement: string;
+        static callSignatureElement: string;
+        static indexSignatureElement: string;
+        static constructSignatureElement: string;
+        static parameterElement: string;
+        static typeParameterElement: string;
+        static primitiveType: string;
+        static label: string;
+        static alias: string;
+        static constElement: string;
+        static letElement: string;
+    }
+    class ScriptElementKindModifier {
+        static none: string;
+        static publicMemberModifier: string;
+        static privateMemberModifier: string;
+        static protectedMemberModifier: string;
+        static exportedModifier: string;
+        static ambientModifier: string;
+        static staticModifier: string;
+    }
+    class ClassificationTypeNames {
+        static comment: string;
+        static identifier: string;
+        static keyword: string;
+        static numericLiteral: string;
+        static operator: string;
+        static stringLiteral: string;
+        static whiteSpace: string;
+        static text: string;
+        static punctuation: string;
+        static className: string;
+        static enumName: string;
+        static interfaceName: string;
+        static moduleName: string;
+        static typeParameterName: string;
+        static typeAlias: string;
+    }
+    interface DisplayPartsSymbolWriter extends SymbolWriter {
+        displayParts(): SymbolDisplayPart[];
+    }
+    function displayPartsToString(displayParts: SymbolDisplayPart[]): string;
+    function getDefaultCompilerOptions(): CompilerOptions;
+    class OperationCanceledException {
+    }
+    class CancellationTokenObject {
+        private cancellationToken;
+        static None: CancellationTokenObject;
+        constructor(cancellationToken: CancellationToken);
+        isCancellationRequested(): boolean;
+        throwIfCancellationRequested(): void;
+    }
+    function createDocumentRegistry(): DocumentRegistry;
+    function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;
+    function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService;
+    function createClassifier(host: Logger): Classifier;
+}
+
+
+//// [APISample_node_compile.js]
+var ts = require("typescript");
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", 2 /* Latest */, "0.0");
+var program = ts.createProgram(["file1.ts"], {}, undefined);
diff --git a/tests/baselines/reference/APISample_node_compile.types b/tests/baselines/reference/APISample_node_compile.types
new file mode 100644
index 00000000000..347c5aa358e
--- /dev/null
+++ b/tests/baselines/reference/APISample_node_compile.types
@@ -0,0 +1,5749 @@
+=== tests/cases/compiler/APISample_node_compile.ts ===
+
+import ts = require("typescript");
+>ts : typeof ts
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+>sourceFile : ts.SourceFile
+>ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0") : ts.SourceFile
+>ts.createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile
+>ts : typeof ts
+>createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile
+>ts.ScriptTarget.Latest : ts.ScriptTarget
+>ts.ScriptTarget : typeof ts.ScriptTarget
+>ts : typeof ts
+>ScriptTarget : typeof ts.ScriptTarget
+>Latest : ts.ScriptTarget
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
+>program : ts.Program
+>ts.createProgram(["file1.ts"], {}, undefined) : ts.Program
+>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program
+>ts : typeof ts
+>createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program
+>["file1.ts"] : string[]
+>{} : { [x: string]: undefined; }
+>undefined : undefined
+
+=== typescript.d.ts ===
+/*! *****************************************************************************

+Copyright (c) Microsoft Corporation. All rights reserved. 

+Licensed under the Apache License, Version 2.0 (the "License"); you may not use

+this file except in compliance with the License. You may obtain a copy of the

+License at http://www.apache.org/licenses/LICENSE-2.0  

+ 

+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 

+MERCHANTABLITY OR NON-INFRINGEMENT. 

+ 

+See the Apache Version 2.0 License for specific language governing permissions

+and limitations under the License.

+***************************************************************************** */

+

+declare module "typescript" {

+    interface Map<T> {

+>Map : Map<T>
+>T : T
+
+        [index: string]: T;

+>index : string
+>T : T
+    }

+    interface TextRange {

+>TextRange : TextRange
+
+        pos: number;

+>pos : number
+
+        end: number;

+>end : number
+    }

+    const enum SyntaxKind {

+>SyntaxKind : SyntaxKind
+
+        Unknown = 0,

+>Unknown : SyntaxKind
+
+        EndOfFileToken = 1,

+>EndOfFileToken : SyntaxKind
+
+        SingleLineCommentTrivia = 2,

+>SingleLineCommentTrivia : SyntaxKind
+
+        MultiLineCommentTrivia = 3,

+>MultiLineCommentTrivia : SyntaxKind
+
+        NewLineTrivia = 4,

+>NewLineTrivia : SyntaxKind
+
+        WhitespaceTrivia = 5,

+>WhitespaceTrivia : SyntaxKind
+
+        NumericLiteral = 6,

+>NumericLiteral : SyntaxKind
+
+        StringLiteral = 7,

+>StringLiteral : SyntaxKind
+
+        RegularExpressionLiteral = 8,

+>RegularExpressionLiteral : SyntaxKind
+
+        NoSubstitutionTemplateLiteral = 9,

+>NoSubstitutionTemplateLiteral : SyntaxKind
+
+        TemplateHead = 10,

+>TemplateHead : SyntaxKind
+
+        TemplateMiddle = 11,

+>TemplateMiddle : SyntaxKind
+
+        TemplateTail = 12,

+>TemplateTail : SyntaxKind
+
+        OpenBraceToken = 13,

+>OpenBraceToken : SyntaxKind
+
+        CloseBraceToken = 14,

+>CloseBraceToken : SyntaxKind
+
+        OpenParenToken = 15,

+>OpenParenToken : SyntaxKind
+
+        CloseParenToken = 16,

+>CloseParenToken : SyntaxKind
+
+        OpenBracketToken = 17,

+>OpenBracketToken : SyntaxKind
+
+        CloseBracketToken = 18,

+>CloseBracketToken : SyntaxKind
+
+        DotToken = 19,

+>DotToken : SyntaxKind
+
+        DotDotDotToken = 20,

+>DotDotDotToken : SyntaxKind
+
+        SemicolonToken = 21,

+>SemicolonToken : SyntaxKind
+
+        CommaToken = 22,

+>CommaToken : SyntaxKind
+
+        LessThanToken = 23,

+>LessThanToken : SyntaxKind
+
+        GreaterThanToken = 24,

+>GreaterThanToken : SyntaxKind
+
+        LessThanEqualsToken = 25,

+>LessThanEqualsToken : SyntaxKind
+
+        GreaterThanEqualsToken = 26,

+>GreaterThanEqualsToken : SyntaxKind
+
+        EqualsEqualsToken = 27,

+>EqualsEqualsToken : SyntaxKind
+
+        ExclamationEqualsToken = 28,

+>ExclamationEqualsToken : SyntaxKind
+
+        EqualsEqualsEqualsToken = 29,

+>EqualsEqualsEqualsToken : SyntaxKind
+
+        ExclamationEqualsEqualsToken = 30,

+>ExclamationEqualsEqualsToken : SyntaxKind
+
+        EqualsGreaterThanToken = 31,

+>EqualsGreaterThanToken : SyntaxKind
+
+        PlusToken = 32,

+>PlusToken : SyntaxKind
+
+        MinusToken = 33,

+>MinusToken : SyntaxKind
+
+        AsteriskToken = 34,

+>AsteriskToken : SyntaxKind
+
+        SlashToken = 35,

+>SlashToken : SyntaxKind
+
+        PercentToken = 36,

+>PercentToken : SyntaxKind
+
+        PlusPlusToken = 37,

+>PlusPlusToken : SyntaxKind
+
+        MinusMinusToken = 38,

+>MinusMinusToken : SyntaxKind
+
+        LessThanLessThanToken = 39,

+>LessThanLessThanToken : SyntaxKind
+
+        GreaterThanGreaterThanToken = 40,

+>GreaterThanGreaterThanToken : SyntaxKind
+
+        GreaterThanGreaterThanGreaterThanToken = 41,

+>GreaterThanGreaterThanGreaterThanToken : SyntaxKind
+
+        AmpersandToken = 42,

+>AmpersandToken : SyntaxKind
+
+        BarToken = 43,

+>BarToken : SyntaxKind
+
+        CaretToken = 44,

+>CaretToken : SyntaxKind
+
+        ExclamationToken = 45,

+>ExclamationToken : SyntaxKind
+
+        TildeToken = 46,

+>TildeToken : SyntaxKind
+
+        AmpersandAmpersandToken = 47,

+>AmpersandAmpersandToken : SyntaxKind
+
+        BarBarToken = 48,

+>BarBarToken : SyntaxKind
+
+        QuestionToken = 49,

+>QuestionToken : SyntaxKind
+
+        ColonToken = 50,

+>ColonToken : SyntaxKind
+
+        EqualsToken = 51,

+>EqualsToken : SyntaxKind
+
+        PlusEqualsToken = 52,

+>PlusEqualsToken : SyntaxKind
+
+        MinusEqualsToken = 53,

+>MinusEqualsToken : SyntaxKind
+
+        AsteriskEqualsToken = 54,

+>AsteriskEqualsToken : SyntaxKind
+
+        SlashEqualsToken = 55,

+>SlashEqualsToken : SyntaxKind
+
+        PercentEqualsToken = 56,

+>PercentEqualsToken : SyntaxKind
+
+        LessThanLessThanEqualsToken = 57,

+>LessThanLessThanEqualsToken : SyntaxKind
+
+        GreaterThanGreaterThanEqualsToken = 58,

+>GreaterThanGreaterThanEqualsToken : SyntaxKind
+
+        GreaterThanGreaterThanGreaterThanEqualsToken = 59,

+>GreaterThanGreaterThanGreaterThanEqualsToken : SyntaxKind
+
+        AmpersandEqualsToken = 60,

+>AmpersandEqualsToken : SyntaxKind
+
+        BarEqualsToken = 61,

+>BarEqualsToken : SyntaxKind
+
+        CaretEqualsToken = 62,

+>CaretEqualsToken : SyntaxKind
+
+        Identifier = 63,

+>Identifier : SyntaxKind
+
+        BreakKeyword = 64,

+>BreakKeyword : SyntaxKind
+
+        CaseKeyword = 65,

+>CaseKeyword : SyntaxKind
+
+        CatchKeyword = 66,

+>CatchKeyword : SyntaxKind
+
+        ClassKeyword = 67,

+>ClassKeyword : SyntaxKind
+
+        ConstKeyword = 68,

+>ConstKeyword : SyntaxKind
+
+        ContinueKeyword = 69,

+>ContinueKeyword : SyntaxKind
+
+        DebuggerKeyword = 70,

+>DebuggerKeyword : SyntaxKind
+
+        DefaultKeyword = 71,

+>DefaultKeyword : SyntaxKind
+
+        DeleteKeyword = 72,

+>DeleteKeyword : SyntaxKind
+
+        DoKeyword = 73,

+>DoKeyword : SyntaxKind
+
+        ElseKeyword = 74,

+>ElseKeyword : SyntaxKind
+
+        EnumKeyword = 75,

+>EnumKeyword : SyntaxKind
+
+        ExportKeyword = 76,

+>ExportKeyword : SyntaxKind
+
+        ExtendsKeyword = 77,

+>ExtendsKeyword : SyntaxKind
+
+        FalseKeyword = 78,

+>FalseKeyword : SyntaxKind
+
+        FinallyKeyword = 79,

+>FinallyKeyword : SyntaxKind
+
+        ForKeyword = 80,

+>ForKeyword : SyntaxKind
+
+        FunctionKeyword = 81,

+>FunctionKeyword : SyntaxKind
+
+        IfKeyword = 82,

+>IfKeyword : SyntaxKind
+
+        ImportKeyword = 83,

+>ImportKeyword : SyntaxKind
+
+        InKeyword = 84,

+>InKeyword : SyntaxKind
+
+        InstanceOfKeyword = 85,

+>InstanceOfKeyword : SyntaxKind
+
+        NewKeyword = 86,

+>NewKeyword : SyntaxKind
+
+        NullKeyword = 87,

+>NullKeyword : SyntaxKind
+
+        ReturnKeyword = 88,

+>ReturnKeyword : SyntaxKind
+
+        SuperKeyword = 89,

+>SuperKeyword : SyntaxKind
+
+        SwitchKeyword = 90,

+>SwitchKeyword : SyntaxKind
+
+        ThisKeyword = 91,

+>ThisKeyword : SyntaxKind
+
+        ThrowKeyword = 92,

+>ThrowKeyword : SyntaxKind
+
+        TrueKeyword = 93,

+>TrueKeyword : SyntaxKind
+
+        TryKeyword = 94,

+>TryKeyword : SyntaxKind
+
+        TypeOfKeyword = 95,

+>TypeOfKeyword : SyntaxKind
+
+        VarKeyword = 96,

+>VarKeyword : SyntaxKind
+
+        VoidKeyword = 97,

+>VoidKeyword : SyntaxKind
+
+        WhileKeyword = 98,

+>WhileKeyword : SyntaxKind
+
+        WithKeyword = 99,

+>WithKeyword : SyntaxKind
+
+        ImplementsKeyword = 100,

+>ImplementsKeyword : SyntaxKind
+
+        InterfaceKeyword = 101,

+>InterfaceKeyword : SyntaxKind
+
+        LetKeyword = 102,

+>LetKeyword : SyntaxKind
+
+        PackageKeyword = 103,

+>PackageKeyword : SyntaxKind
+
+        PrivateKeyword = 104,

+>PrivateKeyword : SyntaxKind
+
+        ProtectedKeyword = 105,

+>ProtectedKeyword : SyntaxKind
+
+        PublicKeyword = 106,

+>PublicKeyword : SyntaxKind
+
+        StaticKeyword = 107,

+>StaticKeyword : SyntaxKind
+
+        YieldKeyword = 108,

+>YieldKeyword : SyntaxKind
+
+        AnyKeyword = 109,

+>AnyKeyword : SyntaxKind
+
+        BooleanKeyword = 110,

+>BooleanKeyword : SyntaxKind
+
+        ConstructorKeyword = 111,

+>ConstructorKeyword : SyntaxKind
+
+        DeclareKeyword = 112,

+>DeclareKeyword : SyntaxKind
+
+        GetKeyword = 113,

+>GetKeyword : SyntaxKind
+
+        ModuleKeyword = 114,

+>ModuleKeyword : SyntaxKind
+
+        RequireKeyword = 115,

+>RequireKeyword : SyntaxKind
+
+        NumberKeyword = 116,

+>NumberKeyword : SyntaxKind
+
+        SetKeyword = 117,

+>SetKeyword : SyntaxKind
+
+        StringKeyword = 118,

+>StringKeyword : SyntaxKind
+
+        TypeKeyword = 119,

+>TypeKeyword : SyntaxKind
+
+        QualifiedName = 120,

+>QualifiedName : SyntaxKind
+
+        ComputedPropertyName = 121,

+>ComputedPropertyName : SyntaxKind
+
+        TypeParameter = 122,

+>TypeParameter : SyntaxKind
+
+        Parameter = 123,

+>Parameter : SyntaxKind
+
+        Property = 124,

+>Property : SyntaxKind
+
+        Method = 125,

+>Method : SyntaxKind
+
+        Constructor = 126,

+>Constructor : SyntaxKind
+
+        GetAccessor = 127,

+>GetAccessor : SyntaxKind
+
+        SetAccessor = 128,

+>SetAccessor : SyntaxKind
+
+        CallSignature = 129,

+>CallSignature : SyntaxKind
+
+        ConstructSignature = 130,

+>ConstructSignature : SyntaxKind
+
+        IndexSignature = 131,

+>IndexSignature : SyntaxKind
+
+        TypeReference = 132,

+>TypeReference : SyntaxKind
+
+        FunctionType = 133,

+>FunctionType : SyntaxKind
+
+        ConstructorType = 134,

+>ConstructorType : SyntaxKind
+
+        TypeQuery = 135,

+>TypeQuery : SyntaxKind
+
+        TypeLiteral = 136,

+>TypeLiteral : SyntaxKind
+
+        ArrayType = 137,

+>ArrayType : SyntaxKind
+
+        TupleType = 138,

+>TupleType : SyntaxKind
+
+        UnionType = 139,

+>UnionType : SyntaxKind
+
+        ParenthesizedType = 140,

+>ParenthesizedType : SyntaxKind
+
+        ArrayLiteralExpression = 141,

+>ArrayLiteralExpression : SyntaxKind
+
+        ObjectLiteralExpression = 142,

+>ObjectLiteralExpression : SyntaxKind
+
+        PropertyAccessExpression = 143,

+>PropertyAccessExpression : SyntaxKind
+
+        ElementAccessExpression = 144,

+>ElementAccessExpression : SyntaxKind
+
+        CallExpression = 145,

+>CallExpression : SyntaxKind
+
+        NewExpression = 146,

+>NewExpression : SyntaxKind
+
+        TaggedTemplateExpression = 147,

+>TaggedTemplateExpression : SyntaxKind
+
+        TypeAssertionExpression = 148,

+>TypeAssertionExpression : SyntaxKind
+
+        ParenthesizedExpression = 149,

+>ParenthesizedExpression : SyntaxKind
+
+        FunctionExpression = 150,

+>FunctionExpression : SyntaxKind
+
+        ArrowFunction = 151,

+>ArrowFunction : SyntaxKind
+
+        DeleteExpression = 152,

+>DeleteExpression : SyntaxKind
+
+        TypeOfExpression = 153,

+>TypeOfExpression : SyntaxKind
+
+        VoidExpression = 154,

+>VoidExpression : SyntaxKind
+
+        PrefixUnaryExpression = 155,

+>PrefixUnaryExpression : SyntaxKind
+
+        PostfixUnaryExpression = 156,

+>PostfixUnaryExpression : SyntaxKind
+
+        BinaryExpression = 157,

+>BinaryExpression : SyntaxKind
+
+        ConditionalExpression = 158,

+>ConditionalExpression : SyntaxKind
+
+        TemplateExpression = 159,

+>TemplateExpression : SyntaxKind
+
+        YieldExpression = 160,

+>YieldExpression : SyntaxKind
+
+        OmittedExpression = 161,

+>OmittedExpression : SyntaxKind
+
+        TemplateSpan = 162,

+>TemplateSpan : SyntaxKind
+
+        Block = 163,

+>Block : SyntaxKind
+
+        VariableStatement = 164,

+>VariableStatement : SyntaxKind
+
+        EmptyStatement = 165,

+>EmptyStatement : SyntaxKind
+
+        ExpressionStatement = 166,

+>ExpressionStatement : SyntaxKind
+
+        IfStatement = 167,

+>IfStatement : SyntaxKind
+
+        DoStatement = 168,

+>DoStatement : SyntaxKind
+
+        WhileStatement = 169,

+>WhileStatement : SyntaxKind
+
+        ForStatement = 170,

+>ForStatement : SyntaxKind
+
+        ForInStatement = 171,

+>ForInStatement : SyntaxKind
+
+        ContinueStatement = 172,

+>ContinueStatement : SyntaxKind
+
+        BreakStatement = 173,

+>BreakStatement : SyntaxKind
+
+        ReturnStatement = 174,

+>ReturnStatement : SyntaxKind
+
+        WithStatement = 175,

+>WithStatement : SyntaxKind
+
+        SwitchStatement = 176,

+>SwitchStatement : SyntaxKind
+
+        LabeledStatement = 177,

+>LabeledStatement : SyntaxKind
+
+        ThrowStatement = 178,

+>ThrowStatement : SyntaxKind
+
+        TryStatement = 179,

+>TryStatement : SyntaxKind
+
+        TryBlock = 180,

+>TryBlock : SyntaxKind
+
+        FinallyBlock = 181,

+>FinallyBlock : SyntaxKind
+
+        DebuggerStatement = 182,

+>DebuggerStatement : SyntaxKind
+
+        VariableDeclaration = 183,

+>VariableDeclaration : SyntaxKind
+
+        FunctionDeclaration = 184,

+>FunctionDeclaration : SyntaxKind
+
+        ClassDeclaration = 185,

+>ClassDeclaration : SyntaxKind
+
+        InterfaceDeclaration = 186,

+>InterfaceDeclaration : SyntaxKind
+
+        TypeAliasDeclaration = 187,

+>TypeAliasDeclaration : SyntaxKind
+
+        EnumDeclaration = 188,

+>EnumDeclaration : SyntaxKind
+
+        ModuleDeclaration = 189,

+>ModuleDeclaration : SyntaxKind
+
+        ModuleBlock = 190,

+>ModuleBlock : SyntaxKind
+
+        ImportDeclaration = 191,

+>ImportDeclaration : SyntaxKind
+
+        ExportAssignment = 192,

+>ExportAssignment : SyntaxKind
+
+        ExternalModuleReference = 193,

+>ExternalModuleReference : SyntaxKind
+
+        CaseClause = 194,

+>CaseClause : SyntaxKind
+
+        DefaultClause = 195,

+>DefaultClause : SyntaxKind
+
+        HeritageClause = 196,

+>HeritageClause : SyntaxKind
+
+        CatchClause = 197,

+>CatchClause : SyntaxKind
+
+        PropertyAssignment = 198,

+>PropertyAssignment : SyntaxKind
+
+        ShorthandPropertyAssignment = 199,

+>ShorthandPropertyAssignment : SyntaxKind
+
+        EnumMember = 200,

+>EnumMember : SyntaxKind
+
+        SourceFile = 201,

+>SourceFile : SyntaxKind
+
+        Program = 202,

+>Program : SyntaxKind
+
+        SyntaxList = 203,

+>SyntaxList : SyntaxKind
+
+        Count = 204,

+>Count : SyntaxKind
+
+        FirstAssignment = 51,

+>FirstAssignment : SyntaxKind
+
+        LastAssignment = 62,

+>LastAssignment : SyntaxKind
+
+        FirstReservedWord = 64,

+>FirstReservedWord : SyntaxKind
+
+        LastReservedWord = 99,

+>LastReservedWord : SyntaxKind
+
+        FirstKeyword = 64,

+>FirstKeyword : SyntaxKind
+
+        LastKeyword = 119,

+>LastKeyword : SyntaxKind
+
+        FirstFutureReservedWord = 100,

+>FirstFutureReservedWord : SyntaxKind
+
+        LastFutureReservedWord = 108,

+>LastFutureReservedWord : SyntaxKind
+
+        FirstTypeNode = 132,

+>FirstTypeNode : SyntaxKind
+
+        LastTypeNode = 140,

+>LastTypeNode : SyntaxKind
+
+        FirstPunctuation = 13,

+>FirstPunctuation : SyntaxKind
+
+        LastPunctuation = 62,

+>LastPunctuation : SyntaxKind
+
+        FirstToken = 0,

+>FirstToken : SyntaxKind
+
+        LastToken = 119,

+>LastToken : SyntaxKind
+
+        FirstTriviaToken = 2,

+>FirstTriviaToken : SyntaxKind
+
+        LastTriviaToken = 5,

+>LastTriviaToken : SyntaxKind
+
+        FirstLiteralToken = 6,

+>FirstLiteralToken : SyntaxKind
+
+        LastLiteralToken = 9,

+>LastLiteralToken : SyntaxKind
+
+        FirstTemplateToken = 9,

+>FirstTemplateToken : SyntaxKind
+
+        LastTemplateToken = 12,

+>LastTemplateToken : SyntaxKind
+
+        FirstOperator = 21,

+>FirstOperator : SyntaxKind
+
+        LastOperator = 62,

+>LastOperator : SyntaxKind
+
+        FirstBinaryOperator = 23,

+>FirstBinaryOperator : SyntaxKind
+
+        LastBinaryOperator = 62,

+>LastBinaryOperator : SyntaxKind
+
+        FirstNode = 120,

+>FirstNode : SyntaxKind
+    }

+    const enum NodeFlags {

+>NodeFlags : NodeFlags
+
+        Export = 1,

+>Export : NodeFlags
+
+        Ambient = 2,

+>Ambient : NodeFlags
+
+        Public = 16,

+>Public : NodeFlags
+
+        Private = 32,

+>Private : NodeFlags
+
+        Protected = 64,

+>Protected : NodeFlags
+
+        Static = 128,

+>Static : NodeFlags
+
+        MultiLine = 256,

+>MultiLine : NodeFlags
+
+        Synthetic = 512,

+>Synthetic : NodeFlags
+
+        DeclarationFile = 1024,

+>DeclarationFile : NodeFlags
+
+        Let = 2048,

+>Let : NodeFlags
+
+        Const = 4096,

+>Const : NodeFlags
+
+        OctalLiteral = 8192,

+>OctalLiteral : NodeFlags
+
+        Modifier = 243,

+>Modifier : NodeFlags
+
+        AccessibilityModifier = 112,

+>AccessibilityModifier : NodeFlags
+
+        BlockScoped = 6144,

+>BlockScoped : NodeFlags
+    }

+    const enum ParserContextFlags {

+>ParserContextFlags : ParserContextFlags
+
+        StrictMode = 1,

+>StrictMode : ParserContextFlags
+
+        DisallowIn = 2,

+>DisallowIn : ParserContextFlags
+
+        Yield = 4,

+>Yield : ParserContextFlags
+
+        GeneratorParameter = 8,

+>GeneratorParameter : ParserContextFlags
+
+        ContainsError = 16,

+>ContainsError : ParserContextFlags
+
+        HasPropagatedChildContainsErrorFlag = 32,

+>HasPropagatedChildContainsErrorFlag : ParserContextFlags
+    }

+    interface Node extends TextRange {

+>Node : Node
+>TextRange : TextRange
+
+        kind: SyntaxKind;

+>kind : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        flags: NodeFlags;

+>flags : NodeFlags
+>NodeFlags : NodeFlags
+
+        parserContextFlags?: ParserContextFlags;

+>parserContextFlags : ParserContextFlags
+>ParserContextFlags : ParserContextFlags
+
+        id?: number;

+>id : number
+
+        parent?: Node;

+>parent : Node
+>Node : Node
+
+        symbol?: Symbol;

+>symbol : Symbol
+>Symbol : Symbol
+
+        locals?: SymbolTable;

+>locals : SymbolTable
+>SymbolTable : SymbolTable
+
+        nextContainer?: Node;

+>nextContainer : Node
+>Node : Node
+
+        localSymbol?: Symbol;

+>localSymbol : Symbol
+>Symbol : Symbol
+
+        modifiers?: ModifiersArray;

+>modifiers : ModifiersArray
+>ModifiersArray : ModifiersArray
+    }

+    interface NodeArray<T> extends Array<T>, TextRange {

+>NodeArray : NodeArray<T>
+>T : T
+>Array : T[]
+>T : T
+>TextRange : TextRange
+
+        hasTrailingComma?: boolean;

+>hasTrailingComma : boolean
+    }

+    interface ModifiersArray extends NodeArray<Node> {

+>ModifiersArray : ModifiersArray
+>NodeArray : NodeArray<T>
+>Node : Node
+
+        flags: number;

+>flags : number
+    }

+    interface Identifier extends PrimaryExpression {

+>Identifier : Identifier
+>PrimaryExpression : PrimaryExpression
+
+        text: string;

+>text : string
+    }

+    interface QualifiedName extends Node {

+>QualifiedName : QualifiedName
+>Node : Node
+
+        left: EntityName;

+>left : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+
+        right: Identifier;

+>right : Identifier
+>Identifier : Identifier
+    }

+    type EntityName = Identifier | QualifiedName;

+>EntityName : Identifier | QualifiedName
+>Identifier : Identifier
+>QualifiedName : QualifiedName
+
+    type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName;

+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+>Identifier : Identifier
+>LiteralExpression : LiteralExpression
+>ComputedPropertyName : ComputedPropertyName
+
+    interface Declaration extends Node {

+>Declaration : Declaration
+>Node : Node
+
+        _declarationBrand: any;

+>_declarationBrand : any
+
+        name?: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+    }

+    interface ComputedPropertyName extends Node {

+>ComputedPropertyName : ComputedPropertyName
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface TypeParameterDeclaration extends Declaration {

+>TypeParameterDeclaration : TypeParameterDeclaration
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        constraint?: TypeNode;

+>constraint : TypeNode
+>TypeNode : TypeNode
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface SignatureDeclaration extends Declaration {

+>SignatureDeclaration : SignatureDeclaration
+>Declaration : Declaration
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        parameters: NodeArray<ParameterDeclaration>;

+>parameters : NodeArray<ParameterDeclaration>
+>NodeArray : NodeArray<T>
+>ParameterDeclaration : ParameterDeclaration
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface VariableDeclaration extends Declaration {

+>VariableDeclaration : VariableDeclaration
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface ParameterDeclaration extends Declaration {

+>ParameterDeclaration : ParameterDeclaration
+>Declaration : Declaration
+
+        dotDotDotToken?: Node;

+>dotDotDotToken : Node
+>Node : Node
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        type?: TypeNode | StringLiteralExpression;

+>type : TypeNode | StringLiteralExpression
+>TypeNode : TypeNode
+>StringLiteralExpression : StringLiteralExpression
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface PropertyDeclaration extends Declaration, ClassElement {

+>PropertyDeclaration : PropertyDeclaration
+>Declaration : Declaration
+>ClassElement : ClassElement
+
+        _propertyDeclarationBrand: any;

+>_propertyDeclarationBrand : any
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration;

+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>VariableDeclaration : VariableDeclaration
+>ParameterDeclaration : ParameterDeclaration
+
+    type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration;

+>VariableOrParameterOrPropertyDeclaration : ParameterDeclaration | VariableDeclaration | PropertyDeclaration
+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>PropertyDeclaration : PropertyDeclaration
+
+    interface ObjectLiteralElement extends Declaration {

+>ObjectLiteralElement : ObjectLiteralElement
+>Declaration : Declaration
+
+        _objectLiteralBrandBrand: any;

+>_objectLiteralBrandBrand : any
+    }

+    interface ShorthandPropertyAssignment extends ObjectLiteralElement {

+>ShorthandPropertyAssignment : ShorthandPropertyAssignment
+>ObjectLiteralElement : ObjectLiteralElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+    }

+    interface PropertyAssignment extends ObjectLiteralElement {

+>PropertyAssignment : PropertyAssignment
+>ObjectLiteralElement : ObjectLiteralElement
+
+        _propertyAssignmentBrand: any;

+>_propertyAssignmentBrand : any
+
+        name: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        initializer: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    /**

+     * Several node kinds share function-like features such as a signature,

+     * a name, and a body. These nodes should extend FunctionLikeDeclaration.

+     * Examples:

+     *  FunctionDeclaration

+     *  MethodDeclaration

+     *  AccessorDeclaration

+     */

+    interface FunctionLikeDeclaration extends SignatureDeclaration {

+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        _functionLikeDeclarationBrand: any;

+>_functionLikeDeclarationBrand : any
+
+        asteriskToken?: Node;

+>asteriskToken : Node
+>Node : Node
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        body?: Block | Expression;

+>body : Expression | Block
+>Block : Block
+>Expression : Expression
+    }

+    interface FunctionDeclaration extends FunctionLikeDeclaration, Statement {

+>FunctionDeclaration : FunctionDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>Statement : Statement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

+>MethodDeclaration : MethodDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+>ObjectLiteralElement : ObjectLiteralElement
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {

+>ConstructorDeclaration : ConstructorDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

+>AccessorDeclaration : AccessorDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+>ObjectLiteralElement : ObjectLiteralElement
+
+        _accessorDeclarationBrand: any;

+>_accessorDeclarationBrand : any
+
+        body: Block;

+>body : Block
+>Block : Block
+    }

+    interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement {

+>IndexSignatureDeclaration : IndexSignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>ClassElement : ClassElement
+
+        _indexSignatureDeclarationBrand: any;

+>_indexSignatureDeclarationBrand : any
+    }

+    interface TypeNode extends Node {

+>TypeNode : TypeNode
+>Node : Node
+
+        _typeNodeBrand: any;

+>_typeNodeBrand : any
+    }

+    interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {

+>FunctionOrConstructorTypeNode : FunctionOrConstructorTypeNode
+>TypeNode : TypeNode
+>SignatureDeclaration : SignatureDeclaration
+
+        _functionOrConstructorTypeNodeBrand: any;

+>_functionOrConstructorTypeNodeBrand : any
+    }

+    interface TypeReferenceNode extends TypeNode {

+>TypeReferenceNode : TypeReferenceNode
+>TypeNode : TypeNode
+
+        typeName: EntityName;

+>typeName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+
+        typeArguments?: NodeArray<TypeNode>;

+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface TypeQueryNode extends TypeNode {

+>TypeQueryNode : TypeQueryNode
+>TypeNode : TypeNode
+
+        exprName: EntityName;

+>exprName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+    }

+    interface TypeLiteralNode extends TypeNode, Declaration {

+>TypeLiteralNode : TypeLiteralNode
+>TypeNode : TypeNode
+>Declaration : Declaration
+
+        members: NodeArray<Node>;

+>members : NodeArray<Node>
+>NodeArray : NodeArray<T>
+>Node : Node
+    }

+    interface ArrayTypeNode extends TypeNode {

+>ArrayTypeNode : ArrayTypeNode
+>TypeNode : TypeNode
+
+        elementType: TypeNode;

+>elementType : TypeNode
+>TypeNode : TypeNode
+    }

+    interface TupleTypeNode extends TypeNode {

+>TupleTypeNode : TupleTypeNode
+>TypeNode : TypeNode
+
+        elementTypes: NodeArray<TypeNode>;

+>elementTypes : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface UnionTypeNode extends TypeNode {

+>UnionTypeNode : UnionTypeNode
+>TypeNode : TypeNode
+
+        types: NodeArray<TypeNode>;

+>types : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface ParenthesizedTypeNode extends TypeNode {

+>ParenthesizedTypeNode : ParenthesizedTypeNode
+>TypeNode : TypeNode
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface Expression extends Node {

+>Expression : Expression
+>Node : Node
+
+        _expressionBrand: any;

+>_expressionBrand : any
+
+        contextualType?: Type;

+>contextualType : Type
+>Type : Type
+    }

+    interface UnaryExpression extends Expression {

+>UnaryExpression : UnaryExpression
+>Expression : Expression
+
+        _unaryExpressionBrand: any;

+>_unaryExpressionBrand : any
+    }

+    interface PrefixUnaryExpression extends UnaryExpression {

+>PrefixUnaryExpression : PrefixUnaryExpression
+>UnaryExpression : UnaryExpression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        operand: UnaryExpression;

+>operand : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface PostfixUnaryExpression extends PostfixExpression {

+>PostfixUnaryExpression : PostfixUnaryExpression
+>PostfixExpression : PostfixExpression
+
+        operand: LeftHandSideExpression;

+>operand : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+    }

+    interface PostfixExpression extends UnaryExpression {

+>PostfixExpression : PostfixExpression
+>UnaryExpression : UnaryExpression
+
+        _postfixExpressionBrand: any;

+>_postfixExpressionBrand : any
+    }

+    interface LeftHandSideExpression extends PostfixExpression {

+>LeftHandSideExpression : LeftHandSideExpression
+>PostfixExpression : PostfixExpression
+
+        _leftHandSideExpressionBrand: any;

+>_leftHandSideExpressionBrand : any
+    }

+    interface MemberExpression extends LeftHandSideExpression {

+>MemberExpression : MemberExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        _memberExpressionBrand: any;

+>_memberExpressionBrand : any
+    }

+    interface PrimaryExpression extends MemberExpression {

+>PrimaryExpression : PrimaryExpression
+>MemberExpression : MemberExpression
+
+        _primaryExpressionBrand: any;

+>_primaryExpressionBrand : any
+    }

+    interface DeleteExpression extends UnaryExpression {

+>DeleteExpression : DeleteExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface TypeOfExpression extends UnaryExpression {

+>TypeOfExpression : TypeOfExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface VoidExpression extends UnaryExpression {

+>VoidExpression : VoidExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface YieldExpression extends Expression {

+>YieldExpression : YieldExpression
+>Expression : Expression
+
+        asteriskToken?: Node;

+>asteriskToken : Node
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface BinaryExpression extends Expression {

+>BinaryExpression : BinaryExpression
+>Expression : Expression
+
+        left: Expression;

+>left : Expression
+>Expression : Expression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        right: Expression;

+>right : Expression
+>Expression : Expression
+    }

+    interface ConditionalExpression extends Expression {

+>ConditionalExpression : ConditionalExpression
+>Expression : Expression
+
+        condition: Expression;

+>condition : Expression
+>Expression : Expression
+
+        whenTrue: Expression;

+>whenTrue : Expression
+>Expression : Expression
+
+        whenFalse: Expression;

+>whenFalse : Expression
+>Expression : Expression
+    }

+    interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {

+>FunctionExpression : FunctionExpression
+>PrimaryExpression : PrimaryExpression
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        name?: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        body: Block | Expression;

+>body : Expression | Block
+>Block : Block
+>Expression : Expression
+    }

+    interface LiteralExpression extends PrimaryExpression {

+>LiteralExpression : LiteralExpression
+>PrimaryExpression : PrimaryExpression
+
+        text: string;

+>text : string
+
+        isUnterminated?: boolean;

+>isUnterminated : boolean
+    }

+    interface StringLiteralExpression extends LiteralExpression {

+>StringLiteralExpression : StringLiteralExpression
+>LiteralExpression : LiteralExpression
+
+        _stringLiteralExpressionBrand: any;

+>_stringLiteralExpressionBrand : any
+    }

+    interface TemplateExpression extends PrimaryExpression {

+>TemplateExpression : TemplateExpression
+>PrimaryExpression : PrimaryExpression
+
+        head: LiteralExpression;

+>head : LiteralExpression
+>LiteralExpression : LiteralExpression
+
+        templateSpans: NodeArray<TemplateSpan>;

+>templateSpans : NodeArray<TemplateSpan>
+>NodeArray : NodeArray<T>
+>TemplateSpan : TemplateSpan
+    }

+    interface TemplateSpan extends Node {

+>TemplateSpan : TemplateSpan
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        literal: LiteralExpression;

+>literal : LiteralExpression
+>LiteralExpression : LiteralExpression
+    }

+    interface ParenthesizedExpression extends PrimaryExpression {

+>ParenthesizedExpression : ParenthesizedExpression
+>PrimaryExpression : PrimaryExpression
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ArrayLiteralExpression extends PrimaryExpression {

+>ArrayLiteralExpression : ArrayLiteralExpression
+>PrimaryExpression : PrimaryExpression
+
+        elements: NodeArray<Expression>;

+>elements : NodeArray<Expression>
+>NodeArray : NodeArray<T>
+>Expression : Expression
+    }

+    interface ObjectLiteralExpression extends PrimaryExpression, Declaration {

+>ObjectLiteralExpression : ObjectLiteralExpression
+>PrimaryExpression : PrimaryExpression
+>Declaration : Declaration
+
+        properties: NodeArray<ObjectLiteralElement>;

+>properties : NodeArray<ObjectLiteralElement>
+>NodeArray : NodeArray<T>
+>ObjectLiteralElement : ObjectLiteralElement
+    }

+    interface PropertyAccessExpression extends MemberExpression {

+>PropertyAccessExpression : PropertyAccessExpression
+>MemberExpression : MemberExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+    }

+    interface ElementAccessExpression extends MemberExpression {

+>ElementAccessExpression : ElementAccessExpression
+>MemberExpression : MemberExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        argumentExpression?: Expression;

+>argumentExpression : Expression
+>Expression : Expression
+    }

+    interface CallExpression extends LeftHandSideExpression {

+>CallExpression : CallExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;

+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+
+        arguments: NodeArray<Expression>;

+>arguments : NodeArray<Expression>
+>NodeArray : NodeArray<T>
+>Expression : Expression
+    }

+    interface NewExpression extends CallExpression, PrimaryExpression {

+>NewExpression : NewExpression
+>CallExpression : CallExpression
+>PrimaryExpression : PrimaryExpression
+    }

+    interface TaggedTemplateExpression extends MemberExpression {

+>TaggedTemplateExpression : TaggedTemplateExpression
+>MemberExpression : MemberExpression
+
+        tag: LeftHandSideExpression;

+>tag : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        template: LiteralExpression | TemplateExpression;

+>template : LiteralExpression | TemplateExpression
+>LiteralExpression : LiteralExpression
+>TemplateExpression : TemplateExpression
+    }

+    type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;

+>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression
+>CallExpression : CallExpression
+>NewExpression : NewExpression
+>TaggedTemplateExpression : TaggedTemplateExpression
+
+    interface TypeAssertion extends UnaryExpression {

+>TypeAssertion : TypeAssertion
+>UnaryExpression : UnaryExpression
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface Statement extends Node, ModuleElement {

+>Statement : Statement
+>Node : Node
+>ModuleElement : ModuleElement
+
+        _statementBrand: any;

+>_statementBrand : any
+    }

+    interface Block extends Statement {

+>Block : Block
+>Statement : Statement
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    interface VariableStatement extends Statement {

+>VariableStatement : VariableStatement
+>Statement : Statement
+
+        declarations: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+    }

+    interface ExpressionStatement extends Statement {

+>ExpressionStatement : ExpressionStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface IfStatement extends Statement {

+>IfStatement : IfStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        thenStatement: Statement;

+>thenStatement : Statement
+>Statement : Statement
+
+        elseStatement?: Statement;

+>elseStatement : Statement
+>Statement : Statement
+    }

+    interface IterationStatement extends Statement {

+>IterationStatement : IterationStatement
+>Statement : Statement
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface DoStatement extends IterationStatement {

+>DoStatement : DoStatement
+>IterationStatement : IterationStatement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface WhileStatement extends IterationStatement {

+>WhileStatement : WhileStatement
+>IterationStatement : IterationStatement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ForStatement extends IterationStatement {

+>ForStatement : ForStatement
+>IterationStatement : IterationStatement
+
+        declarations?: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+
+        condition?: Expression;

+>condition : Expression
+>Expression : Expression
+
+        iterator?: Expression;

+>iterator : Expression
+>Expression : Expression
+    }

+    interface ForInStatement extends IterationStatement {

+>ForInStatement : ForInStatement
+>IterationStatement : IterationStatement
+
+        declarations?: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+
+        variable?: Expression;

+>variable : Expression
+>Expression : Expression
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface BreakOrContinueStatement extends Statement {

+>BreakOrContinueStatement : BreakOrContinueStatement
+>Statement : Statement
+
+        label?: Identifier;

+>label : Identifier
+>Identifier : Identifier
+    }

+    interface ReturnStatement extends Statement {

+>ReturnStatement : ReturnStatement
+>Statement : Statement
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface WithStatement extends Statement {

+>WithStatement : WithStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface SwitchStatement extends Statement {

+>SwitchStatement : SwitchStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        clauses: NodeArray<CaseOrDefaultClause>;

+>clauses : NodeArray<CaseClause | DefaultClause>
+>NodeArray : NodeArray<T>
+>CaseOrDefaultClause : CaseClause | DefaultClause
+    }

+    interface CaseClause extends Node {

+>CaseClause : CaseClause
+>Node : Node
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    interface DefaultClause extends Node {

+>DefaultClause : DefaultClause
+>Node : Node
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    type CaseOrDefaultClause = CaseClause | DefaultClause;

+>CaseOrDefaultClause : CaseClause | DefaultClause
+>CaseClause : CaseClause
+>DefaultClause : DefaultClause
+
+    interface LabeledStatement extends Statement {

+>LabeledStatement : LabeledStatement
+>Statement : Statement
+
+        label: Identifier;

+>label : Identifier
+>Identifier : Identifier
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface ThrowStatement extends Statement {

+>ThrowStatement : ThrowStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface TryStatement extends Statement {

+>TryStatement : TryStatement
+>Statement : Statement
+
+        tryBlock: Block;

+>tryBlock : Block
+>Block : Block
+
+        catchClause?: CatchClause;

+>catchClause : CatchClause
+>CatchClause : CatchClause
+
+        finallyBlock?: Block;

+>finallyBlock : Block
+>Block : Block
+    }

+    interface CatchClause extends Declaration {

+>CatchClause : CatchClause
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        block: Block;

+>block : Block
+>Block : Block
+    }

+    interface ModuleElement extends Node {

+>ModuleElement : ModuleElement
+>Node : Node
+
+        _moduleElementBrand: any;

+>_moduleElementBrand : any
+    }

+    interface ClassDeclaration extends Declaration, ModuleElement {

+>ClassDeclaration : ClassDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        heritageClauses?: NodeArray<HeritageClause>;

+>heritageClauses : NodeArray<HeritageClause>
+>NodeArray : NodeArray<T>
+>HeritageClause : HeritageClause
+
+        members: NodeArray<ClassElement>;

+>members : NodeArray<ClassElement>
+>NodeArray : NodeArray<T>
+>ClassElement : ClassElement
+    }

+    interface ClassElement extends Declaration {

+>ClassElement : ClassElement
+>Declaration : Declaration
+
+        _classElementBrand: any;

+>_classElementBrand : any
+    }

+    interface InterfaceDeclaration extends Declaration, ModuleElement {

+>InterfaceDeclaration : InterfaceDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        heritageClauses?: NodeArray<HeritageClause>;

+>heritageClauses : NodeArray<HeritageClause>
+>NodeArray : NodeArray<T>
+>HeritageClause : HeritageClause
+
+        members: NodeArray<Declaration>;

+>members : NodeArray<Declaration>
+>NodeArray : NodeArray<T>
+>Declaration : Declaration
+    }

+    interface HeritageClause extends Node {

+>HeritageClause : HeritageClause
+>Node : Node
+
+        token: SyntaxKind;

+>token : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        types?: NodeArray<TypeReferenceNode>;

+>types : NodeArray<TypeReferenceNode>
+>NodeArray : NodeArray<T>
+>TypeReferenceNode : TypeReferenceNode
+    }

+    interface TypeAliasDeclaration extends Declaration, ModuleElement {

+>TypeAliasDeclaration : TypeAliasDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface EnumMember extends Declaration {

+>EnumMember : EnumMember
+>Declaration : Declaration
+
+        name: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface EnumDeclaration extends Declaration, ModuleElement {

+>EnumDeclaration : EnumDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        members: NodeArray<EnumMember>;

+>members : NodeArray<EnumMember>
+>NodeArray : NodeArray<T>
+>EnumMember : EnumMember
+    }

+    interface ModuleDeclaration extends Declaration, ModuleElement {

+>ModuleDeclaration : ModuleDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier | LiteralExpression;

+>name : Identifier | LiteralExpression
+>Identifier : Identifier
+>LiteralExpression : LiteralExpression
+
+        body: ModuleBlock | ModuleDeclaration;

+>body : ModuleDeclaration | ModuleBlock
+>ModuleBlock : ModuleBlock
+>ModuleDeclaration : ModuleDeclaration
+    }

+    interface ModuleBlock extends Node, ModuleElement {

+>ModuleBlock : ModuleBlock
+>Node : Node
+>ModuleElement : ModuleElement
+
+        statements: NodeArray<ModuleElement>;

+>statements : NodeArray<ModuleElement>
+>NodeArray : NodeArray<T>
+>ModuleElement : ModuleElement
+    }

+    interface ImportDeclaration extends Declaration, ModuleElement {

+>ImportDeclaration : ImportDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        moduleReference: EntityName | ExternalModuleReference;

+>moduleReference : Identifier | QualifiedName | ExternalModuleReference
+>EntityName : Identifier | QualifiedName
+>ExternalModuleReference : ExternalModuleReference
+    }

+    interface ExternalModuleReference extends Node {

+>ExternalModuleReference : ExternalModuleReference
+>Node : Node
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ExportAssignment extends Statement, ModuleElement {

+>ExportAssignment : ExportAssignment
+>Statement : Statement
+>ModuleElement : ModuleElement
+
+        exportName: Identifier;

+>exportName : Identifier
+>Identifier : Identifier
+    }

+    interface FileReference extends TextRange {

+>FileReference : FileReference
+>TextRange : TextRange
+
+        filename: string;

+>filename : string
+    }

+    interface CommentRange extends TextRange {

+>CommentRange : CommentRange
+>TextRange : TextRange
+
+        hasTrailingNewLine?: boolean;

+>hasTrailingNewLine : boolean
+    }

+    interface SourceFile extends Declaration {

+>SourceFile : SourceFile
+>Declaration : Declaration
+
+        statements: NodeArray<ModuleElement>;

+>statements : NodeArray<ModuleElement>
+>NodeArray : NodeArray<T>
+>ModuleElement : ModuleElement
+
+        endOfFileToken: Node;

+>endOfFileToken : Node
+>Node : Node
+
+        filename: string;

+>filename : string
+
+        text: string;

+>text : string
+
+        getLineAndCharacterFromPosition(position: number): LineAndCharacter;

+>getLineAndCharacterFromPosition : (position: number) => LineAndCharacter
+>position : number
+>LineAndCharacter : LineAndCharacter
+
+        getPositionFromLineAndCharacter(line: number, character: number): number;

+>getPositionFromLineAndCharacter : (line: number, character: number) => number
+>line : number
+>character : number
+
+        getLineStarts(): number[];

+>getLineStarts : () => number[]
+
+        amdDependencies: string[];

+>amdDependencies : string[]
+
+        amdModuleName: string;

+>amdModuleName : string
+
+        referencedFiles: FileReference[];

+>referencedFiles : FileReference[]
+>FileReference : FileReference
+
+        referenceDiagnostics: Diagnostic[];

+>referenceDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        parseDiagnostics: Diagnostic[];

+>parseDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        grammarDiagnostics: Diagnostic[];

+>grammarDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getSyntacticDiagnostics(): Diagnostic[];

+>getSyntacticDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        semanticDiagnostics: Diagnostic[];

+>semanticDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        hasNoDefaultLib: boolean;

+>hasNoDefaultLib : boolean
+
+        externalModuleIndicator: Node;

+>externalModuleIndicator : Node
+>Node : Node
+
+        nodeCount: number;

+>nodeCount : number
+
+        identifierCount: number;

+>identifierCount : number
+
+        symbolCount: number;

+>symbolCount : number
+
+        isOpen: boolean;

+>isOpen : boolean
+
+        version: string;

+>version : string
+
+        languageVersion: ScriptTarget;

+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+        identifiers: Map<string>;

+>identifiers : Map<string>
+>Map : Map<T>
+    }

+    interface Program {

+>Program : Program
+
+        getSourceFile(filename: string): SourceFile;

+>getSourceFile : (filename: string) => SourceFile
+>filename : string
+>SourceFile : SourceFile
+
+        getSourceFiles(): SourceFile[];

+>getSourceFiles : () => SourceFile[]
+>SourceFile : SourceFile
+
+        getCompilerOptions(): CompilerOptions;

+>getCompilerOptions : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getCompilerHost(): CompilerHost;

+>getCompilerHost : () => CompilerHost
+>CompilerHost : CompilerHost
+
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

+>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getGlobalDiagnostics(): Diagnostic[];

+>getGlobalDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getTypeChecker(fullTypeCheckMode: boolean): TypeChecker;

+>getTypeChecker : (fullTypeCheckMode: boolean) => TypeChecker
+>fullTypeCheckMode : boolean
+>TypeChecker : TypeChecker
+
+        getCommonSourceDirectory(): string;

+>getCommonSourceDirectory : () => string
+    }

+    interface SourceMapSpan {

+>SourceMapSpan : SourceMapSpan
+
+        emittedLine: number;

+>emittedLine : number
+
+        emittedColumn: number;

+>emittedColumn : number
+
+        sourceLine: number;

+>sourceLine : number
+
+        sourceColumn: number;

+>sourceColumn : number
+
+        nameIndex?: number;

+>nameIndex : number
+
+        sourceIndex: number;

+>sourceIndex : number
+    }

+    interface SourceMapData {

+>SourceMapData : SourceMapData
+
+        sourceMapFilePath: string;

+>sourceMapFilePath : string
+
+        jsSourceMappingURL: string;

+>jsSourceMappingURL : string
+
+        sourceMapFile: string;

+>sourceMapFile : string
+
+        sourceMapSourceRoot: string;

+>sourceMapSourceRoot : string
+
+        sourceMapSources: string[];

+>sourceMapSources : string[]
+
+        inputSourceFileNames: string[];

+>inputSourceFileNames : string[]
+
+        sourceMapNames?: string[];

+>sourceMapNames : string[]
+
+        sourceMapMappings: string;

+>sourceMapMappings : string
+
+        sourceMapDecodedMappings: SourceMapSpan[];

+>sourceMapDecodedMappings : SourceMapSpan[]
+>SourceMapSpan : SourceMapSpan
+    }

+    enum EmitReturnStatus {

+>EmitReturnStatus : EmitReturnStatus
+
+        Succeeded = 0,

+>Succeeded : EmitReturnStatus
+
+        AllOutputGenerationSkipped = 1,

+>AllOutputGenerationSkipped : EmitReturnStatus
+
+        JSGeneratedWithSemanticErrors = 2,

+>JSGeneratedWithSemanticErrors : EmitReturnStatus
+
+        DeclarationGenerationSkipped = 3,

+>DeclarationGenerationSkipped : EmitReturnStatus
+
+        EmitErrorsEncountered = 4,

+>EmitErrorsEncountered : EmitReturnStatus
+
+        CompilerOptionsErrors = 5,

+>CompilerOptionsErrors : EmitReturnStatus
+    }

+    interface EmitResult {

+>EmitResult : EmitResult
+
+        emitResultStatus: EmitReturnStatus;

+>emitResultStatus : EmitReturnStatus
+>EmitReturnStatus : EmitReturnStatus
+
+        diagnostics: Diagnostic[];

+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        sourceMaps: SourceMapData[];

+>sourceMaps : SourceMapData[]
+>SourceMapData : SourceMapData
+    }

+    interface TypeChecker {

+>TypeChecker : TypeChecker
+
+        getProgram(): Program;

+>getProgram : () => Program
+>Program : Program
+
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

+>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[];

+>getDeclarationDiagnostics : (sourceFile: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getGlobalDiagnostics(): Diagnostic[];

+>getGlobalDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getNodeCount(): number;

+>getNodeCount : () => number
+
+        getIdentifierCount(): number;

+>getIdentifierCount : () => number
+
+        getSymbolCount(): number;

+>getSymbolCount : () => number
+
+        getTypeCount(): number;

+>getTypeCount : () => number
+
+        emitFiles(targetSourceFile?: SourceFile): EmitResult;

+>emitFiles : (targetSourceFile?: SourceFile) => EmitResult
+>targetSourceFile : SourceFile
+>SourceFile : SourceFile
+>EmitResult : EmitResult
+
+        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;

+>getTypeOfSymbolAtLocation : (symbol: Symbol, node: Node) => Type
+>symbol : Symbol
+>Symbol : Symbol
+>node : Node
+>Node : Node
+>Type : Type
+
+        getDeclaredTypeOfSymbol(symbol: Symbol): Type;

+>getDeclaredTypeOfSymbol : (symbol: Symbol) => Type
+>symbol : Symbol
+>Symbol : Symbol
+>Type : Type
+
+        getPropertiesOfType(type: Type): Symbol[];

+>getPropertiesOfType : (type: Type) => Symbol[]
+>type : Type
+>Type : Type
+>Symbol : Symbol
+
+        getPropertyOfType(type: Type, propertyName: string): Symbol;

+>getPropertyOfType : (type: Type, propertyName: string) => Symbol
+>type : Type
+>Type : Type
+>propertyName : string
+>Symbol : Symbol
+
+        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];

+>getSignaturesOfType : (type: Type, kind: SignatureKind) => Signature[]
+>type : Type
+>Type : Type
+>kind : SignatureKind
+>SignatureKind : SignatureKind
+>Signature : Signature
+
+        getIndexTypeOfType(type: Type, kind: IndexKind): Type;

+>getIndexTypeOfType : (type: Type, kind: IndexKind) => Type
+>type : Type
+>Type : Type
+>kind : IndexKind
+>IndexKind : IndexKind
+>Type : Type
+
+        getReturnTypeOfSignature(signature: Signature): Type;

+>getReturnTypeOfSignature : (signature: Signature) => Type
+>signature : Signature
+>Signature : Signature
+>Type : Type
+
+        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];

+>getSymbolsInScope : (location: Node, meaning: SymbolFlags) => Symbol[]
+>location : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>Symbol : Symbol
+
+        getSymbolAtLocation(node: Node): Symbol;

+>getSymbolAtLocation : (node: Node) => Symbol
+>node : Node
+>Node : Node
+>Symbol : Symbol
+
+        getShorthandAssignmentValueSymbol(location: Node): Symbol;

+>getShorthandAssignmentValueSymbol : (location: Node) => Symbol
+>location : Node
+>Node : Node
+>Symbol : Symbol
+
+        getTypeAtLocation(node: Node): Type;

+>getTypeAtLocation : (node: Node) => Type
+>node : Node
+>Node : Node
+>Type : Type
+
+        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;

+>typeToString : (type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => string
+>type : Type
+>Type : Type
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;

+>symbolToString : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => string
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        getSymbolDisplayBuilder(): SymbolDisplayBuilder;

+>getSymbolDisplayBuilder : () => SymbolDisplayBuilder
+>SymbolDisplayBuilder : SymbolDisplayBuilder
+
+        getFullyQualifiedName(symbol: Symbol): string;

+>getFullyQualifiedName : (symbol: Symbol) => string
+>symbol : Symbol
+>Symbol : Symbol
+
+        getAugmentedPropertiesOfType(type: Type): Symbol[];

+>getAugmentedPropertiesOfType : (type: Type) => Symbol[]
+>type : Type
+>Type : Type
+>Symbol : Symbol
+
+        getRootSymbols(symbol: Symbol): Symbol[];

+>getRootSymbols : (symbol: Symbol) => Symbol[]
+>symbol : Symbol
+>Symbol : Symbol
+>Symbol : Symbol
+
+        getContextualType(node: Expression): Type;

+>getContextualType : (node: Expression) => Type
+>node : Expression
+>Expression : Expression
+>Type : Type
+
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;

+>getResolvedSignature : (node: CallExpression | NewExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]) => Signature
+>node : CallExpression | NewExpression | TaggedTemplateExpression
+>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression
+>candidatesOutArray : Signature[]
+>Signature : Signature
+>Signature : Signature
+
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;

+>getSignatureFromDeclaration : (declaration: SignatureDeclaration) => Signature
+>declaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>Signature : Signature
+
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;

+>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean
+>node : FunctionLikeDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        isUndefinedSymbol(symbol: Symbol): boolean;

+>isUndefinedSymbol : (symbol: Symbol) => boolean
+>symbol : Symbol
+>Symbol : Symbol
+
+        isArgumentsSymbol(symbol: Symbol): boolean;

+>isArgumentsSymbol : (symbol: Symbol) => boolean
+>symbol : Symbol
+>Symbol : Symbol
+
+        isEmitBlocked(sourceFile?: SourceFile): boolean;

+>isEmitBlocked : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getEnumMemberValue(node: EnumMember): number;

+>getEnumMemberValue : (node: EnumMember) => number
+>node : EnumMember
+>EnumMember : EnumMember
+
+        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;

+>isValidPropertyAccess : (node: QualifiedName | PropertyAccessExpression, propertyName: string) => boolean
+>node : QualifiedName | PropertyAccessExpression
+>PropertyAccessExpression : PropertyAccessExpression
+>QualifiedName : QualifiedName
+>propertyName : string
+
+        getAliasedSymbol(symbol: Symbol): Symbol;

+>getAliasedSymbol : (symbol: Symbol) => Symbol
+>symbol : Symbol
+>Symbol : Symbol
+>Symbol : Symbol
+    }

+    interface SymbolDisplayBuilder {

+>SymbolDisplayBuilder : SymbolDisplayBuilder
+
+        buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildTypeDisplay : (type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>type : Type
+>Type : Type
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;

+>buildSymbolDisplay : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>flags : SymbolFormatFlags
+>SymbolFormatFlags : SymbolFormatFlags
+
+        buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildSignatureDisplay : (signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>signatures : Signature
+>Signature : Signature
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildParameterDisplay : (parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>parameter : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildTypeParameterDisplay : (tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>tp : TypeParameter
+>TypeParameter : TypeParameter
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;

+>buildTypeParameterDisplayFromSymbol : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaraiton : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildDisplayForParametersAndDelimiters : (parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>parameters : Symbol[]
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildDisplayForTypeParametersAndDelimiters : (typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildReturnTypeDisplay : (signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>signature : Signature
+>Signature : Signature
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+    }

+    interface SymbolWriter {

+>SymbolWriter : SymbolWriter
+
+        writeKeyword(text: string): void;

+>writeKeyword : (text: string) => void
+>text : string
+
+        writeOperator(text: string): void;

+>writeOperator : (text: string) => void
+>text : string
+
+        writePunctuation(text: string): void;

+>writePunctuation : (text: string) => void
+>text : string
+
+        writeSpace(text: string): void;

+>writeSpace : (text: string) => void
+>text : string
+
+        writeStringLiteral(text: string): void;

+>writeStringLiteral : (text: string) => void
+>text : string
+
+        writeParameter(text: string): void;

+>writeParameter : (text: string) => void
+>text : string
+
+        writeSymbol(text: string, symbol: Symbol): void;

+>writeSymbol : (text: string, symbol: Symbol) => void
+>text : string
+>symbol : Symbol
+>Symbol : Symbol
+
+        writeLine(): void;

+>writeLine : () => void
+
+        increaseIndent(): void;

+>increaseIndent : () => void
+
+        decreaseIndent(): void;

+>decreaseIndent : () => void
+
+        clear(): void;

+>clear : () => void
+
+        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;

+>trackSymbol : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+    }

+    const enum TypeFormatFlags {

+>TypeFormatFlags : TypeFormatFlags
+
+        None = 0,

+>None : TypeFormatFlags
+
+        WriteArrayAsGenericType = 1,

+>WriteArrayAsGenericType : TypeFormatFlags
+
+        UseTypeOfFunction = 2,

+>UseTypeOfFunction : TypeFormatFlags
+
+        NoTruncation = 4,

+>NoTruncation : TypeFormatFlags
+
+        WriteArrowStyleSignature = 8,

+>WriteArrowStyleSignature : TypeFormatFlags
+
+        WriteOwnNameForAnyLike = 16,

+>WriteOwnNameForAnyLike : TypeFormatFlags
+
+        WriteTypeArgumentsOfSignature = 32,

+>WriteTypeArgumentsOfSignature : TypeFormatFlags
+
+        InElementType = 64,

+>InElementType : TypeFormatFlags
+    }

+    const enum SymbolFormatFlags {

+>SymbolFormatFlags : SymbolFormatFlags
+
+        None = 0,

+>None : SymbolFormatFlags
+
+        WriteTypeParametersOrArguments = 1,

+>WriteTypeParametersOrArguments : SymbolFormatFlags
+
+        UseOnlyExternalAliasing = 2,

+>UseOnlyExternalAliasing : SymbolFormatFlags
+    }

+    const enum SymbolAccessibility {

+>SymbolAccessibility : SymbolAccessibility
+
+        Accessible = 0,

+>Accessible : SymbolAccessibility
+
+        NotAccessible = 1,

+>NotAccessible : SymbolAccessibility
+
+        CannotBeNamed = 2,

+>CannotBeNamed : SymbolAccessibility
+    }

+    interface SymbolVisibilityResult {

+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        accessibility: SymbolAccessibility;

+>accessibility : SymbolAccessibility
+>SymbolAccessibility : SymbolAccessibility
+
+        aliasesToMakeVisible?: ImportDeclaration[];

+>aliasesToMakeVisible : ImportDeclaration[]
+>ImportDeclaration : ImportDeclaration
+
+        errorSymbolName?: string;

+>errorSymbolName : string
+
+        errorNode?: Node;

+>errorNode : Node
+>Node : Node
+    }

+    interface SymbolAccessiblityResult extends SymbolVisibilityResult {

+>SymbolAccessiblityResult : SymbolAccessiblityResult
+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        errorModuleName?: string;

+>errorModuleName : string
+    }

+    interface EmitResolver {

+>EmitResolver : EmitResolver
+
+        getProgram(): Program;

+>getProgram : () => Program
+>Program : Program
+
+        getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string;

+>getLocalNameOfContainer : (container: EnumDeclaration | ModuleDeclaration) => string
+>container : EnumDeclaration | ModuleDeclaration
+>ModuleDeclaration : ModuleDeclaration
+>EnumDeclaration : EnumDeclaration
+
+        getExpressionNamePrefix(node: Identifier): string;

+>getExpressionNamePrefix : (node: Identifier) => string
+>node : Identifier
+>Identifier : Identifier
+
+        getExportAssignmentName(node: SourceFile): string;

+>getExportAssignmentName : (node: SourceFile) => string
+>node : SourceFile
+>SourceFile : SourceFile
+
+        isReferencedImportDeclaration(node: ImportDeclaration): boolean;

+>isReferencedImportDeclaration : (node: ImportDeclaration) => boolean
+>node : ImportDeclaration
+>ImportDeclaration : ImportDeclaration
+
+        isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean;

+>isTopLevelValueImportWithEntityName : (node: ImportDeclaration) => boolean
+>node : ImportDeclaration
+>ImportDeclaration : ImportDeclaration
+
+        getNodeCheckFlags(node: Node): NodeCheckFlags;

+>getNodeCheckFlags : (node: Node) => NodeCheckFlags
+>node : Node
+>Node : Node
+>NodeCheckFlags : NodeCheckFlags
+
+        getEnumMemberValue(node: EnumMember): number;

+>getEnumMemberValue : (node: EnumMember) => number
+>node : EnumMember
+>EnumMember : EnumMember
+
+        hasSemanticErrors(sourceFile?: SourceFile): boolean;

+>hasSemanticErrors : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        isDeclarationVisible(node: Declaration): boolean;

+>isDeclarationVisible : (node: Declaration) => boolean
+>node : Declaration
+>Declaration : Declaration
+
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;

+>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean
+>node : FunctionLikeDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;

+>writeTypeOfDeclaration : (declaration: ParameterDeclaration | VariableDeclaration | AccessorDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
+>declaration : ParameterDeclaration | VariableDeclaration | AccessorDeclaration
+>AccessorDeclaration : AccessorDeclaration
+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+
+        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;

+>writeReturnTypeOfSignatureDeclaration : (signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
+>signatureDeclaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;

+>isSymbolAccessible : (symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) => SymbolAccessiblityResult
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>SymbolAccessiblityResult : SymbolAccessiblityResult
+
+        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;

+>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+>enclosingDeclaration : Node
+>Node : Node
+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number;

+>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression) => number
+>node : PropertyAccessExpression | ElementAccessExpression
+>PropertyAccessExpression : PropertyAccessExpression
+>ElementAccessExpression : ElementAccessExpression
+
+        isEmitBlocked(sourceFile?: SourceFile): boolean;

+>isEmitBlocked : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+    }

+    const enum SymbolFlags {

+>SymbolFlags : SymbolFlags
+
+        FunctionScopedVariable = 1,

+>FunctionScopedVariable : SymbolFlags
+
+        BlockScopedVariable = 2,

+>BlockScopedVariable : SymbolFlags
+
+        Property = 4,

+>Property : SymbolFlags
+
+        EnumMember = 8,

+>EnumMember : SymbolFlags
+
+        Function = 16,

+>Function : SymbolFlags
+
+        Class = 32,

+>Class : SymbolFlags
+
+        Interface = 64,

+>Interface : SymbolFlags
+
+        ConstEnum = 128,

+>ConstEnum : SymbolFlags
+
+        RegularEnum = 256,

+>RegularEnum : SymbolFlags
+
+        ValueModule = 512,

+>ValueModule : SymbolFlags
+
+        NamespaceModule = 1024,

+>NamespaceModule : SymbolFlags
+
+        TypeLiteral = 2048,

+>TypeLiteral : SymbolFlags
+
+        ObjectLiteral = 4096,

+>ObjectLiteral : SymbolFlags
+
+        Method = 8192,

+>Method : SymbolFlags
+
+        Constructor = 16384,

+>Constructor : SymbolFlags
+
+        GetAccessor = 32768,

+>GetAccessor : SymbolFlags
+
+        SetAccessor = 65536,

+>SetAccessor : SymbolFlags
+
+        CallSignature = 131072,

+>CallSignature : SymbolFlags
+
+        ConstructSignature = 262144,

+>ConstructSignature : SymbolFlags
+
+        IndexSignature = 524288,

+>IndexSignature : SymbolFlags
+
+        TypeParameter = 1048576,

+>TypeParameter : SymbolFlags
+
+        TypeAlias = 2097152,

+>TypeAlias : SymbolFlags
+
+        ExportValue = 4194304,

+>ExportValue : SymbolFlags
+
+        ExportType = 8388608,

+>ExportType : SymbolFlags
+
+        ExportNamespace = 16777216,

+>ExportNamespace : SymbolFlags
+
+        Import = 33554432,

+>Import : SymbolFlags
+
+        Instantiated = 67108864,

+>Instantiated : SymbolFlags
+
+        Merged = 134217728,

+>Merged : SymbolFlags
+
+        Transient = 268435456,

+>Transient : SymbolFlags
+
+        Prototype = 536870912,

+>Prototype : SymbolFlags
+
+        UnionProperty = 1073741824,

+>UnionProperty : SymbolFlags
+
+        Enum = 384,

+>Enum : SymbolFlags
+
+        Variable = 3,

+>Variable : SymbolFlags
+
+        Value = 107455,

+>Value : SymbolFlags
+
+        Type = 3152352,

+>Type : SymbolFlags
+
+        Namespace = 1536,

+>Namespace : SymbolFlags
+
+        Module = 1536,

+>Module : SymbolFlags
+
+        Accessor = 98304,

+>Accessor : SymbolFlags
+
+        Signature = 917504,

+>Signature : SymbolFlags
+
+        FunctionScopedVariableExcludes = 107454,

+>FunctionScopedVariableExcludes : SymbolFlags
+
+        BlockScopedVariableExcludes = 107455,

+>BlockScopedVariableExcludes : SymbolFlags
+
+        ParameterExcludes = 107455,

+>ParameterExcludes : SymbolFlags
+
+        PropertyExcludes = 107455,

+>PropertyExcludes : SymbolFlags
+
+        EnumMemberExcludes = 107455,

+>EnumMemberExcludes : SymbolFlags
+
+        FunctionExcludes = 106927,

+>FunctionExcludes : SymbolFlags
+
+        ClassExcludes = 3258879,

+>ClassExcludes : SymbolFlags
+
+        InterfaceExcludes = 3152288,

+>InterfaceExcludes : SymbolFlags
+
+        RegularEnumExcludes = 3258623,

+>RegularEnumExcludes : SymbolFlags
+
+        ConstEnumExcludes = 3259263,

+>ConstEnumExcludes : SymbolFlags
+
+        ValueModuleExcludes = 106639,

+>ValueModuleExcludes : SymbolFlags
+
+        NamespaceModuleExcludes = 0,

+>NamespaceModuleExcludes : SymbolFlags
+
+        MethodExcludes = 99263,

+>MethodExcludes : SymbolFlags
+
+        GetAccessorExcludes = 41919,

+>GetAccessorExcludes : SymbolFlags
+
+        SetAccessorExcludes = 74687,

+>SetAccessorExcludes : SymbolFlags
+
+        TypeParameterExcludes = 2103776,

+>TypeParameterExcludes : SymbolFlags
+
+        TypeAliasExcludes = 3152352,

+>TypeAliasExcludes : SymbolFlags
+
+        ImportExcludes = 33554432,

+>ImportExcludes : SymbolFlags
+
+        ModuleMember = 35653619,

+>ModuleMember : SymbolFlags
+
+        ExportHasLocal = 944,

+>ExportHasLocal : SymbolFlags
+
+        HasLocals = 1041936,

+>HasLocals : SymbolFlags
+
+        HasExports = 1952,

+>HasExports : SymbolFlags
+
+        HasMembers = 6240,

+>HasMembers : SymbolFlags
+
+        IsContainer = 1048560,

+>IsContainer : SymbolFlags
+
+        PropertyOrAccessor = 98308,

+>PropertyOrAccessor : SymbolFlags
+
+        Export = 29360128,

+>Export : SymbolFlags
+    }

+    interface Symbol {

+>Symbol : Symbol
+
+        flags: SymbolFlags;

+>flags : SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        name: string;

+>name : string
+
+        id?: number;

+>id : number
+
+        mergeId?: number;

+>mergeId : number
+
+        declarations?: Declaration[];

+>declarations : Declaration[]
+>Declaration : Declaration
+
+        parent?: Symbol;

+>parent : Symbol
+>Symbol : Symbol
+
+        members?: SymbolTable;

+>members : SymbolTable
+>SymbolTable : SymbolTable
+
+        exports?: SymbolTable;

+>exports : SymbolTable
+>SymbolTable : SymbolTable
+
+        exportSymbol?: Symbol;

+>exportSymbol : Symbol
+>Symbol : Symbol
+
+        valueDeclaration?: Declaration;

+>valueDeclaration : Declaration
+>Declaration : Declaration
+
+        constEnumOnlyModule?: boolean;

+>constEnumOnlyModule : boolean
+    }

+    interface SymbolLinks {

+>SymbolLinks : SymbolLinks
+
+        target?: Symbol;

+>target : Symbol
+>Symbol : Symbol
+
+        type?: Type;

+>type : Type
+>Type : Type
+
+        declaredType?: Type;

+>declaredType : Type
+>Type : Type
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+
+        referenced?: boolean;

+>referenced : boolean
+
+        exportAssignSymbol?: Symbol;

+>exportAssignSymbol : Symbol
+>Symbol : Symbol
+
+        unionType?: UnionType;

+>unionType : UnionType
+>UnionType : UnionType
+    }

+    interface TransientSymbol extends Symbol, SymbolLinks {

+>TransientSymbol : TransientSymbol
+>Symbol : Symbol
+>SymbolLinks : SymbolLinks
+    }

+    interface SymbolTable {

+>SymbolTable : SymbolTable
+
+        [index: string]: Symbol;

+>index : string
+>Symbol : Symbol
+    }

+    const enum NodeCheckFlags {

+>NodeCheckFlags : NodeCheckFlags
+
+        TypeChecked = 1,

+>TypeChecked : NodeCheckFlags
+
+        LexicalThis = 2,

+>LexicalThis : NodeCheckFlags
+
+        CaptureThis = 4,

+>CaptureThis : NodeCheckFlags
+
+        EmitExtends = 8,

+>EmitExtends : NodeCheckFlags
+
+        SuperInstance = 16,

+>SuperInstance : NodeCheckFlags
+
+        SuperStatic = 32,

+>SuperStatic : NodeCheckFlags
+
+        ContextChecked = 64,

+>ContextChecked : NodeCheckFlags
+
+        EnumValuesComputed = 128,

+>EnumValuesComputed : NodeCheckFlags
+    }

+    interface NodeLinks {

+>NodeLinks : NodeLinks
+
+        resolvedType?: Type;

+>resolvedType : Type
+>Type : Type
+
+        resolvedSignature?: Signature;

+>resolvedSignature : Signature
+>Signature : Signature
+
+        resolvedSymbol?: Symbol;

+>resolvedSymbol : Symbol
+>Symbol : Symbol
+
+        flags?: NodeCheckFlags;

+>flags : NodeCheckFlags
+>NodeCheckFlags : NodeCheckFlags
+
+        enumMemberValue?: number;

+>enumMemberValue : number
+
+        isIllegalTypeReferenceInConstraint?: boolean;

+>isIllegalTypeReferenceInConstraint : boolean
+
+        isVisible?: boolean;

+>isVisible : boolean
+
+        localModuleName?: string;

+>localModuleName : string
+
+        assignmentChecks?: Map<boolean>;

+>assignmentChecks : Map<boolean>
+>Map : Map<T>
+    }

+    const enum TypeFlags {

+>TypeFlags : TypeFlags
+
+        Any = 1,

+>Any : TypeFlags
+
+        String = 2,

+>String : TypeFlags
+
+        Number = 4,

+>Number : TypeFlags
+
+        Boolean = 8,

+>Boolean : TypeFlags
+
+        Void = 16,

+>Void : TypeFlags
+
+        Undefined = 32,

+>Undefined : TypeFlags
+
+        Null = 64,

+>Null : TypeFlags
+
+        Enum = 128,

+>Enum : TypeFlags
+
+        StringLiteral = 256,

+>StringLiteral : TypeFlags
+
+        TypeParameter = 512,

+>TypeParameter : TypeFlags
+
+        Class = 1024,

+>Class : TypeFlags
+
+        Interface = 2048,

+>Interface : TypeFlags
+
+        Reference = 4096,

+>Reference : TypeFlags
+
+        Tuple = 8192,

+>Tuple : TypeFlags
+
+        Union = 16384,

+>Union : TypeFlags
+
+        Anonymous = 32768,

+>Anonymous : TypeFlags
+
+        FromSignature = 65536,

+>FromSignature : TypeFlags
+
+        Intrinsic = 127,

+>Intrinsic : TypeFlags
+
+        StringLike = 258,

+>StringLike : TypeFlags
+
+        NumberLike = 132,

+>NumberLike : TypeFlags
+
+        ObjectType = 48128,

+>ObjectType : TypeFlags
+    }

+    interface Type {

+>Type : Type
+
+        flags: TypeFlags;

+>flags : TypeFlags
+>TypeFlags : TypeFlags
+
+        id: number;

+>id : number
+
+        symbol?: Symbol;

+>symbol : Symbol
+>Symbol : Symbol
+    }

+    interface IntrinsicType extends Type {

+>IntrinsicType : IntrinsicType
+>Type : Type
+
+        intrinsicName: string;

+>intrinsicName : string
+    }

+    interface StringLiteralType extends Type {

+>StringLiteralType : StringLiteralType
+>Type : Type
+
+        text: string;

+>text : string
+    }

+    interface ObjectType extends Type {

+>ObjectType : ObjectType
+>Type : Type
+    }

+    interface InterfaceType extends ObjectType {

+>InterfaceType : InterfaceType
+>ObjectType : ObjectType
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        baseTypes: ObjectType[];

+>baseTypes : ObjectType[]
+>ObjectType : ObjectType
+
+        declaredProperties: Symbol[];

+>declaredProperties : Symbol[]
+>Symbol : Symbol
+
+        declaredCallSignatures: Signature[];

+>declaredCallSignatures : Signature[]
+>Signature : Signature
+
+        declaredConstructSignatures: Signature[];

+>declaredConstructSignatures : Signature[]
+>Signature : Signature
+
+        declaredStringIndexType: Type;

+>declaredStringIndexType : Type
+>Type : Type
+
+        declaredNumberIndexType: Type;

+>declaredNumberIndexType : Type
+>Type : Type
+    }

+    interface TypeReference extends ObjectType {

+>TypeReference : TypeReference
+>ObjectType : ObjectType
+
+        target: GenericType;

+>target : GenericType
+>GenericType : GenericType
+
+        typeArguments: Type[];

+>typeArguments : Type[]
+>Type : Type
+    }

+    interface GenericType extends InterfaceType, TypeReference {

+>GenericType : GenericType
+>InterfaceType : InterfaceType
+>TypeReference : TypeReference
+
+        instantiations: Map<TypeReference>;

+>instantiations : Map<TypeReference>
+>Map : Map<T>
+>TypeReference : TypeReference
+
+        openReferenceTargets: GenericType[];

+>openReferenceTargets : GenericType[]
+>GenericType : GenericType
+
+        openReferenceChecks: Map<boolean>;

+>openReferenceChecks : Map<boolean>
+>Map : Map<T>
+    }

+    interface TupleType extends ObjectType {

+>TupleType : TupleType
+>ObjectType : ObjectType
+
+        elementTypes: Type[];

+>elementTypes : Type[]
+>Type : Type
+
+        baseArrayType: TypeReference;

+>baseArrayType : TypeReference
+>TypeReference : TypeReference
+    }

+    interface UnionType extends Type {

+>UnionType : UnionType
+>Type : Type
+
+        types: Type[];

+>types : Type[]
+>Type : Type
+
+        resolvedProperties: SymbolTable;

+>resolvedProperties : SymbolTable
+>SymbolTable : SymbolTable
+    }

+    interface ResolvedType extends ObjectType, UnionType {

+>ResolvedType : ResolvedType
+>ObjectType : ObjectType
+>UnionType : UnionType
+
+        members: SymbolTable;

+>members : SymbolTable
+>SymbolTable : SymbolTable
+
+        properties: Symbol[];

+>properties : Symbol[]
+>Symbol : Symbol
+
+        callSignatures: Signature[];

+>callSignatures : Signature[]
+>Signature : Signature
+
+        constructSignatures: Signature[];

+>constructSignatures : Signature[]
+>Signature : Signature
+
+        stringIndexType: Type;

+>stringIndexType : Type
+>Type : Type
+
+        numberIndexType: Type;

+>numberIndexType : Type
+>Type : Type
+    }

+    interface TypeParameter extends Type {

+>TypeParameter : TypeParameter
+>Type : Type
+
+        constraint: Type;

+>constraint : Type
+>Type : Type
+
+        target?: TypeParameter;

+>target : TypeParameter
+>TypeParameter : TypeParameter
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+    }

+    const enum SignatureKind {

+>SignatureKind : SignatureKind
+
+        Call = 0,

+>Call : SignatureKind
+
+        Construct = 1,

+>Construct : SignatureKind
+    }

+    interface Signature {

+>Signature : Signature
+
+        declaration: SignatureDeclaration;

+>declaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        parameters: Symbol[];

+>parameters : Symbol[]
+>Symbol : Symbol
+
+        resolvedReturnType: Type;

+>resolvedReturnType : Type
+>Type : Type
+
+        minArgumentCount: number;

+>minArgumentCount : number
+
+        hasRestParameter: boolean;

+>hasRestParameter : boolean
+
+        hasStringLiterals: boolean;

+>hasStringLiterals : boolean
+
+        target?: Signature;

+>target : Signature
+>Signature : Signature
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+
+        unionSignatures?: Signature[];

+>unionSignatures : Signature[]
+>Signature : Signature
+
+        erasedSignatureCache?: Signature;

+>erasedSignatureCache : Signature
+>Signature : Signature
+
+        isolatedSignatureType?: ObjectType;

+>isolatedSignatureType : ObjectType
+>ObjectType : ObjectType
+    }

+    const enum IndexKind {

+>IndexKind : IndexKind
+
+        String = 0,

+>String : IndexKind
+
+        Number = 1,

+>Number : IndexKind
+    }

+    interface TypeMapper {

+>TypeMapper : TypeMapper
+
+        (t: Type): Type;

+>t : Type
+>Type : Type
+>Type : Type
+    }

+    interface TypeInferences {

+>TypeInferences : TypeInferences
+
+        primary: Type[];

+>primary : Type[]
+>Type : Type
+
+        secondary: Type[];

+>secondary : Type[]
+>Type : Type
+    }

+    interface InferenceContext {

+>InferenceContext : InferenceContext
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        inferUnionTypes: boolean;

+>inferUnionTypes : boolean
+
+        inferences: TypeInferences[];

+>inferences : TypeInferences[]
+>TypeInferences : TypeInferences
+
+        inferredTypes: Type[];

+>inferredTypes : Type[]
+>Type : Type
+
+        failedTypeParameterIndex?: number;

+>failedTypeParameterIndex : number
+    }

+    interface DiagnosticMessage {

+>DiagnosticMessage : DiagnosticMessage
+
+        key: string;

+>key : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        isEarly?: boolean;

+>isEarly : boolean
+    }

+    interface DiagnosticMessageChain {

+>DiagnosticMessageChain : DiagnosticMessageChain
+
+        messageText: string;

+>messageText : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        next?: DiagnosticMessageChain;

+>next : DiagnosticMessageChain
+>DiagnosticMessageChain : DiagnosticMessageChain
+    }

+    interface Diagnostic {

+>Diagnostic : Diagnostic
+
+        file: SourceFile;

+>file : SourceFile
+>SourceFile : SourceFile
+
+        start: number;

+>start : number
+
+        length: number;

+>length : number
+
+        messageText: string;

+>messageText : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        /**

+          * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit

+          */

+        isEarly?: boolean;

+>isEarly : boolean
+    }

+    enum DiagnosticCategory {

+>DiagnosticCategory : DiagnosticCategory
+
+        Warning = 0,

+>Warning : DiagnosticCategory
+
+        Error = 1,

+>Error : DiagnosticCategory
+
+        Message = 2,

+>Message : DiagnosticCategory
+    }

+    interface CompilerOptions {

+>CompilerOptions : CompilerOptions
+
+        allowNonTsExtensions?: boolean;

+>allowNonTsExtensions : boolean
+
+        charset?: string;

+>charset : string
+
+        codepage?: number;

+>codepage : number
+
+        declaration?: boolean;

+>declaration : boolean
+
+        diagnostics?: boolean;

+>diagnostics : boolean
+
+        emitBOM?: boolean;

+>emitBOM : boolean
+
+        help?: boolean;

+>help : boolean
+
+        locale?: string;

+>locale : string
+
+        mapRoot?: string;

+>mapRoot : string
+
+        module?: ModuleKind;

+>module : ModuleKind
+>ModuleKind : ModuleKind
+
+        noEmitOnError?: boolean;

+>noEmitOnError : boolean
+
+        noErrorTruncation?: boolean;

+>noErrorTruncation : boolean
+
+        noImplicitAny?: boolean;

+>noImplicitAny : boolean
+
+        noLib?: boolean;

+>noLib : boolean
+
+        noLibCheck?: boolean;

+>noLibCheck : boolean
+
+        noResolve?: boolean;

+>noResolve : boolean
+
+        out?: string;

+>out : string
+
+        outDir?: string;

+>outDir : string
+
+        preserveConstEnums?: boolean;

+>preserveConstEnums : boolean
+
+        removeComments?: boolean;

+>removeComments : boolean
+
+        sourceMap?: boolean;

+>sourceMap : boolean
+
+        sourceRoot?: string;

+>sourceRoot : string
+
+        suppressImplicitAnyIndexErrors?: boolean;

+>suppressImplicitAnyIndexErrors : boolean
+
+        target?: ScriptTarget;

+>target : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+        version?: boolean;

+>version : boolean
+
+        watch?: boolean;

+>watch : boolean
+
+        [option: string]: string | number | boolean;

+>option : string
+    }

+    const enum ModuleKind {

+>ModuleKind : ModuleKind
+
+        None = 0,

+>None : ModuleKind
+
+        CommonJS = 1,

+>CommonJS : ModuleKind
+
+        AMD = 2,

+>AMD : ModuleKind
+    }

+    interface LineAndCharacter {

+>LineAndCharacter : LineAndCharacter
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+    }

+    const enum ScriptTarget {

+>ScriptTarget : ScriptTarget
+
+        ES3 = 0,

+>ES3 : ScriptTarget
+
+        ES5 = 1,

+>ES5 : ScriptTarget
+
+        ES6 = 2,

+>ES6 : ScriptTarget
+
+        Latest = 2,

+>Latest : ScriptTarget
+    }

+    interface ParsedCommandLine {

+>ParsedCommandLine : ParsedCommandLine
+
+        options: CompilerOptions;

+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        filenames: string[];

+>filenames : string[]
+
+        errors: Diagnostic[];

+>errors : Diagnostic[]
+>Diagnostic : Diagnostic
+    }

+    interface CommandLineOption {

+>CommandLineOption : CommandLineOption
+
+        name: string;

+>name : string
+
+        type: string | Map<number>;

+>type : string | Map<number>
+>Map : Map<T>
+
+        shortName?: string;

+>shortName : string
+
+        description?: DiagnosticMessage;

+>description : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+
+        paramType?: DiagnosticMessage;

+>paramType : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+
+        error?: DiagnosticMessage;

+>error : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+    }

+    const enum CharacterCodes {

+>CharacterCodes : CharacterCodes
+
+        nullCharacter = 0,

+>nullCharacter : CharacterCodes
+
+        maxAsciiCharacter = 127,

+>maxAsciiCharacter : CharacterCodes
+
+        lineFeed = 10,

+>lineFeed : CharacterCodes
+
+        carriageReturn = 13,

+>carriageReturn : CharacterCodes
+
+        lineSeparator = 8232,

+>lineSeparator : CharacterCodes
+
+        paragraphSeparator = 8233,

+>paragraphSeparator : CharacterCodes
+
+        nextLine = 133,

+>nextLine : CharacterCodes
+
+        space = 32,

+>space : CharacterCodes
+
+        nonBreakingSpace = 160,

+>nonBreakingSpace : CharacterCodes
+
+        enQuad = 8192,

+>enQuad : CharacterCodes
+
+        emQuad = 8193,

+>emQuad : CharacterCodes
+
+        enSpace = 8194,

+>enSpace : CharacterCodes
+
+        emSpace = 8195,

+>emSpace : CharacterCodes
+
+        threePerEmSpace = 8196,

+>threePerEmSpace : CharacterCodes
+
+        fourPerEmSpace = 8197,

+>fourPerEmSpace : CharacterCodes
+
+        sixPerEmSpace = 8198,

+>sixPerEmSpace : CharacterCodes
+
+        figureSpace = 8199,

+>figureSpace : CharacterCodes
+
+        punctuationSpace = 8200,

+>punctuationSpace : CharacterCodes
+
+        thinSpace = 8201,

+>thinSpace : CharacterCodes
+
+        hairSpace = 8202,

+>hairSpace : CharacterCodes
+
+        zeroWidthSpace = 8203,

+>zeroWidthSpace : CharacterCodes
+
+        narrowNoBreakSpace = 8239,

+>narrowNoBreakSpace : CharacterCodes
+
+        ideographicSpace = 12288,

+>ideographicSpace : CharacterCodes
+
+        mathematicalSpace = 8287,

+>mathematicalSpace : CharacterCodes
+
+        ogham = 5760,

+>ogham : CharacterCodes
+
+        _ = 95,

+>_ : CharacterCodes
+
+        $ = 36,

+>$ : CharacterCodes
+
+        _0 = 48,

+>_0 : CharacterCodes
+
+        _1 = 49,

+>_1 : CharacterCodes
+
+        _2 = 50,

+>_2 : CharacterCodes
+
+        _3 = 51,

+>_3 : CharacterCodes
+
+        _4 = 52,

+>_4 : CharacterCodes
+
+        _5 = 53,

+>_5 : CharacterCodes
+
+        _6 = 54,

+>_6 : CharacterCodes
+
+        _7 = 55,

+>_7 : CharacterCodes
+
+        _8 = 56,

+>_8 : CharacterCodes
+
+        _9 = 57,

+>_9 : CharacterCodes
+
+        a = 97,

+>a : CharacterCodes
+
+        b = 98,

+>b : CharacterCodes
+
+        c = 99,

+>c : CharacterCodes
+
+        d = 100,

+>d : CharacterCodes
+
+        e = 101,

+>e : CharacterCodes
+
+        f = 102,

+>f : CharacterCodes
+
+        g = 103,

+>g : CharacterCodes
+
+        h = 104,

+>h : CharacterCodes
+
+        i = 105,

+>i : CharacterCodes
+
+        j = 106,

+>j : CharacterCodes
+
+        k = 107,

+>k : CharacterCodes
+
+        l = 108,

+>l : CharacterCodes
+
+        m = 109,

+>m : CharacterCodes
+
+        n = 110,

+>n : CharacterCodes
+
+        o = 111,

+>o : CharacterCodes
+
+        p = 112,

+>p : CharacterCodes
+
+        q = 113,

+>q : CharacterCodes
+
+        r = 114,

+>r : CharacterCodes
+
+        s = 115,

+>s : CharacterCodes
+
+        t = 116,

+>t : CharacterCodes
+
+        u = 117,

+>u : CharacterCodes
+
+        v = 118,

+>v : CharacterCodes
+
+        w = 119,

+>w : CharacterCodes
+
+        x = 120,

+>x : CharacterCodes
+
+        y = 121,

+>y : CharacterCodes
+
+        z = 122,

+>z : CharacterCodes
+
+        A = 65,

+>A : CharacterCodes
+
+        B = 66,

+>B : CharacterCodes
+
+        C = 67,

+>C : CharacterCodes
+
+        D = 68,

+>D : CharacterCodes
+
+        E = 69,

+>E : CharacterCodes
+
+        F = 70,

+>F : CharacterCodes
+
+        G = 71,

+>G : CharacterCodes
+
+        H = 72,

+>H : CharacterCodes
+
+        I = 73,

+>I : CharacterCodes
+
+        J = 74,

+>J : CharacterCodes
+
+        K = 75,

+>K : CharacterCodes
+
+        L = 76,

+>L : CharacterCodes
+
+        M = 77,

+>M : CharacterCodes
+
+        N = 78,

+>N : CharacterCodes
+
+        O = 79,

+>O : CharacterCodes
+
+        P = 80,

+>P : CharacterCodes
+
+        Q = 81,

+>Q : CharacterCodes
+
+        R = 82,

+>R : CharacterCodes
+
+        S = 83,

+>S : CharacterCodes
+
+        T = 84,

+>T : CharacterCodes
+
+        U = 85,

+>U : CharacterCodes
+
+        V = 86,

+>V : CharacterCodes
+
+        W = 87,

+>W : CharacterCodes
+
+        X = 88,

+>X : CharacterCodes
+
+        Y = 89,

+>Y : CharacterCodes
+
+        Z = 90,

+>Z : CharacterCodes
+
+        ampersand = 38,

+>ampersand : CharacterCodes
+
+        asterisk = 42,

+>asterisk : CharacterCodes
+
+        at = 64,

+>at : CharacterCodes
+
+        backslash = 92,

+>backslash : CharacterCodes
+
+        backtick = 96,

+>backtick : CharacterCodes
+
+        bar = 124,

+>bar : CharacterCodes
+
+        caret = 94,

+>caret : CharacterCodes
+
+        closeBrace = 125,

+>closeBrace : CharacterCodes
+
+        closeBracket = 93,

+>closeBracket : CharacterCodes
+
+        closeParen = 41,

+>closeParen : CharacterCodes
+
+        colon = 58,

+>colon : CharacterCodes
+
+        comma = 44,

+>comma : CharacterCodes
+
+        dot = 46,

+>dot : CharacterCodes
+
+        doubleQuote = 34,

+>doubleQuote : CharacterCodes
+
+        equals = 61,

+>equals : CharacterCodes
+
+        exclamation = 33,

+>exclamation : CharacterCodes
+
+        greaterThan = 62,

+>greaterThan : CharacterCodes
+
+        lessThan = 60,

+>lessThan : CharacterCodes
+
+        minus = 45,

+>minus : CharacterCodes
+
+        openBrace = 123,

+>openBrace : CharacterCodes
+
+        openBracket = 91,

+>openBracket : CharacterCodes
+
+        openParen = 40,

+>openParen : CharacterCodes
+
+        percent = 37,

+>percent : CharacterCodes
+
+        plus = 43,

+>plus : CharacterCodes
+
+        question = 63,

+>question : CharacterCodes
+
+        semicolon = 59,

+>semicolon : CharacterCodes
+
+        singleQuote = 39,

+>singleQuote : CharacterCodes
+
+        slash = 47,

+>slash : CharacterCodes
+
+        tilde = 126,

+>tilde : CharacterCodes
+
+        backspace = 8,

+>backspace : CharacterCodes
+
+        formFeed = 12,

+>formFeed : CharacterCodes
+
+        byteOrderMark = 65279,

+>byteOrderMark : CharacterCodes
+
+        tab = 9,

+>tab : CharacterCodes
+
+        verticalTab = 11,

+>verticalTab : CharacterCodes
+    }

+    interface CancellationToken {

+>CancellationToken : CancellationToken
+
+        isCancellationRequested(): boolean;

+>isCancellationRequested : () => boolean
+    }

+    interface CompilerHost {

+>CompilerHost : CompilerHost
+
+        getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;

+>getSourceFile : (filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void) => SourceFile
+>filename : string
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>onError : (message: string) => void
+>message : string
+>SourceFile : SourceFile
+
+        getDefaultLibFilename(options: CompilerOptions): string;

+>getDefaultLibFilename : (options: CompilerOptions) => string
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getCancellationToken?(): CancellationToken;

+>getCancellationToken : () => CancellationToken
+>CancellationToken : CancellationToken
+
+        writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void;

+>writeFile : (filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) => void
+>filename : string
+>data : string
+>writeByteOrderMark : boolean
+>onError : (message: string) => void
+>message : string
+
+        getCurrentDirectory(): string;

+>getCurrentDirectory : () => string
+
+        getCanonicalFileName(fileName: string): string;

+>getCanonicalFileName : (fileName: string) => string
+>fileName : string
+
+        useCaseSensitiveFileNames(): boolean;

+>useCaseSensitiveFileNames : () => boolean
+
+        getNewLine(): string;

+>getNewLine : () => string
+    }

+}

+declare module "typescript" {

+    interface ErrorCallback {

+>ErrorCallback : ErrorCallback
+
+        (message: DiagnosticMessage): void;

+>message : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+    }

+    interface CommentCallback {

+>CommentCallback : CommentCallback
+
+        (pos: number, end: number): void;

+>pos : number
+>end : number
+    }

+    interface Scanner {

+>Scanner : Scanner
+
+        getStartPos(): number;

+>getStartPos : () => number
+
+        getToken(): SyntaxKind;

+>getToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        getTextPos(): number;

+>getTextPos : () => number
+
+        getTokenPos(): number;

+>getTokenPos : () => number
+
+        getTokenText(): string;

+>getTokenText : () => string
+
+        getTokenValue(): string;

+>getTokenValue : () => string
+
+        hasPrecedingLineBreak(): boolean;

+>hasPrecedingLineBreak : () => boolean
+
+        isIdentifier(): boolean;

+>isIdentifier : () => boolean
+
+        isReservedWord(): boolean;

+>isReservedWord : () => boolean
+
+        isUnterminated(): boolean;

+>isUnterminated : () => boolean
+
+        reScanGreaterToken(): SyntaxKind;

+>reScanGreaterToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        reScanSlashToken(): SyntaxKind;

+>reScanSlashToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        reScanTemplateToken(): SyntaxKind;

+>reScanTemplateToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        scan(): SyntaxKind;

+>scan : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        setText(text: string): void;

+>setText : (text: string) => void
+>text : string
+
+        setTextPos(textPos: number): void;

+>setTextPos : (textPos: number) => void
+>textPos : number
+
+        lookAhead<T>(callback: () => T): T;

+>lookAhead : <T>(callback: () => T) => T
+>T : T
+>callback : () => T
+>T : T
+>T : T
+
+        tryScan<T>(callback: () => T): T;

+>tryScan : <T>(callback: () => T) => T
+>T : T
+>callback : () => T
+>T : T
+>T : T
+    }

+    function tokenToString(t: SyntaxKind): string;

+>tokenToString : (t: SyntaxKind) => string
+>t : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+    function computeLineStarts(text: string): number[];

+>computeLineStarts : (text: string) => number[]
+>text : string
+
+    function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number;

+>getPositionFromLineAndCharacter : (lineStarts: number[], line: number, character: number) => number
+>lineStarts : number[]
+>line : number
+>character : number
+
+    function getLineAndCharacterOfPosition(lineStarts: number[], position: number): {

+>getLineAndCharacterOfPosition : (lineStarts: number[], position: number) => { line: number; character: number; }
+>lineStarts : number[]
+>position : number
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+
+    };

+    function positionToLineAndCharacter(text: string, pos: number): {

+>positionToLineAndCharacter : (text: string, pos: number) => { line: number; character: number; }
+>text : string
+>pos : number
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+
+    };

+    function isWhiteSpace(ch: number): boolean;

+>isWhiteSpace : (ch: number) => boolean
+>ch : number
+
+    function isLineBreak(ch: number): boolean;

+>isLineBreak : (ch: number) => boolean
+>ch : number
+
+    function isOctalDigit(ch: number): boolean;

+>isOctalDigit : (ch: number) => boolean
+>ch : number
+
+    function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number;

+>skipTrivia : (text: string, pos: number, stopAfterLineBreak?: boolean) => number
+>text : string
+>pos : number
+>stopAfterLineBreak : boolean
+
+    function getLeadingCommentRanges(text: string, pos: number): CommentRange[];

+>getLeadingCommentRanges : (text: string, pos: number) => CommentRange[]
+>text : string
+>pos : number
+>CommentRange : CommentRange
+
+    function getTrailingCommentRanges(text: string, pos: number): CommentRange[];

+>getTrailingCommentRanges : (text: string, pos: number) => CommentRange[]
+>text : string
+>pos : number
+>CommentRange : CommentRange
+
+    function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;

+>isIdentifierStart : (ch: number, languageVersion: ScriptTarget) => boolean
+>ch : number
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+    function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;

+>isIdentifierPart : (ch: number, languageVersion: ScriptTarget) => boolean
+>ch : number
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner;

+>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback) => Scanner
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>skipTrivia : boolean
+>text : string
+>onError : ErrorCallback
+>ErrorCallback : ErrorCallback
+>Scanner : Scanner
+}

+declare module "typescript" {

+    function getNodeConstructor(kind: SyntaxKind): new () => Node;

+>getNodeConstructor : (kind: SyntaxKind) => new () => Node
+>kind : SyntaxKind
+>SyntaxKind : SyntaxKind
+>Node : Node
+
+    function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T;

+>forEachChild : <T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T) => T
+>T : T
+>node : Node
+>Node : Node
+>cbNode : (node: Node) => T
+>node : Node
+>Node : Node
+>T : T
+>cbNodes : (nodes: Node[]) => T
+>nodes : Node[]
+>Node : Node
+>T : T
+>T : T
+
+    function createCompilerHost(options: CompilerOptions): CompilerHost;

+>createCompilerHost : (options: CompilerOptions) => CompilerHost
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+>CompilerHost : CompilerHost
+
+    function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile;

+>createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile
+>filename : string
+>sourceText : string
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>version : string
+>isOpen : boolean
+>SourceFile : SourceFile
+
+    function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program;

+>createProgram : (rootNames: string[], options: CompilerOptions, host: CompilerHost) => Program
+>rootNames : string[]
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+>host : CompilerHost
+>CompilerHost : CompilerHost
+>Program : Program
+}

+declare module "typescript" {

+    function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker;

+>createTypeChecker : (program: Program, fullTypeCheck: boolean) => TypeChecker
+>program : Program
+>Program : Program
+>fullTypeCheck : boolean
+>TypeChecker : TypeChecker
+}

+declare module "typescript" {

+    var servicesVersion: string;

+>servicesVersion : string
+
+    interface Node {

+>Node : Node
+
+        getSourceFile(): SourceFile;

+>getSourceFile : () => SourceFile
+>SourceFile : SourceFile
+
+        getChildCount(sourceFile?: SourceFile): number;

+>getChildCount : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getChildAt(index: number, sourceFile?: SourceFile): Node;

+>getChildAt : (index: number, sourceFile?: SourceFile) => Node
+>index : number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getChildren(sourceFile?: SourceFile): Node[];

+>getChildren : (sourceFile?: SourceFile) => Node[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getStart(sourceFile?: SourceFile): number;

+>getStart : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullStart(): number;

+>getFullStart : () => number
+
+        getEnd(): number;

+>getEnd : () => number
+
+        getWidth(sourceFile?: SourceFile): number;

+>getWidth : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullWidth(): number;

+>getFullWidth : () => number
+
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;

+>getLeadingTriviaWidth : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullText(sourceFile?: SourceFile): string;

+>getFullText : (sourceFile?: SourceFile) => string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getText(sourceFile?: SourceFile): string;

+>getText : (sourceFile?: SourceFile) => string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFirstToken(sourceFile?: SourceFile): Node;

+>getFirstToken : (sourceFile?: SourceFile) => Node
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getLastToken(sourceFile?: SourceFile): Node;

+>getLastToken : (sourceFile?: SourceFile) => Node
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+    }

+    interface Symbol {

+>Symbol : Symbol
+
+        getFlags(): SymbolFlags;

+>getFlags : () => SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        getName(): string;

+>getName : () => string
+
+        getDeclarations(): Declaration[];

+>getDeclarations : () => Declaration[]
+>Declaration : Declaration
+
+        getDocumentationComment(): SymbolDisplayPart[];

+>getDocumentationComment : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface Type {

+>Type : Type
+
+        getFlags(): TypeFlags;

+>getFlags : () => TypeFlags
+>TypeFlags : TypeFlags
+
+        getSymbol(): Symbol;

+>getSymbol : () => Symbol
+>Symbol : Symbol
+
+        getProperties(): Symbol[];

+>getProperties : () => Symbol[]
+>Symbol : Symbol
+
+        getProperty(propertyName: string): Symbol;

+>getProperty : (propertyName: string) => Symbol
+>propertyName : string
+>Symbol : Symbol
+
+        getApparentProperties(): Symbol[];

+>getApparentProperties : () => Symbol[]
+>Symbol : Symbol
+
+        getCallSignatures(): Signature[];

+>getCallSignatures : () => Signature[]
+>Signature : Signature
+
+        getConstructSignatures(): Signature[];

+>getConstructSignatures : () => Signature[]
+>Signature : Signature
+
+        getStringIndexType(): Type;

+>getStringIndexType : () => Type
+>Type : Type
+
+        getNumberIndexType(): Type;

+>getNumberIndexType : () => Type
+>Type : Type
+    }

+    interface Signature {

+>Signature : Signature
+
+        getDeclaration(): SignatureDeclaration;

+>getDeclaration : () => SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        getTypeParameters(): Type[];

+>getTypeParameters : () => Type[]
+>Type : Type
+
+        getParameters(): Symbol[];

+>getParameters : () => Symbol[]
+>Symbol : Symbol
+
+        getReturnType(): Type;

+>getReturnType : () => Type
+>Type : Type
+
+        getDocumentationComment(): SymbolDisplayPart[];

+>getDocumentationComment : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface SourceFile {

+>SourceFile : SourceFile
+
+        getScriptSnapshot(): IScriptSnapshot;

+>getScriptSnapshot : () => IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+
+        getNamedDeclarations(): Declaration[];

+>getNamedDeclarations : () => Declaration[]
+>Declaration : Declaration
+
+        update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;

+>update : (scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>textChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+>SourceFile : SourceFile
+    }

+    /**

+     * Represents an immutable snapshot of a script at a specified time.Once acquired, the

+     * snapshot is observably immutable. i.e. the same calls with the same parameters will return

+     * the same values.

+     */

+    interface IScriptSnapshot {

+>IScriptSnapshot : IScriptSnapshot
+
+        /** Gets a portion of the script snapshot specified by [start, end). */

+        getText(start: number, end: number): string;

+>getText : (start: number, end: number) => string
+>start : number
+>end : number
+
+        /** Gets the length of this script snapshot. */

+        getLength(): number;

+>getLength : () => number
+
+        /**

+         * This call returns the array containing the start position of every line.

+         * i.e."[0, 10, 55]".  TODO: consider making this optional.  The language service could

+         * always determine this (albeit in a more expensive manner).

+         */

+        getLineStartPositions(): number[];

+>getLineStartPositions : () => number[]
+
+        /**

+         * Gets the TextChangeRange that describe how the text changed between this text and

+         * an older version.  This information is used by the incremental parser to determine

+         * what sections of the script need to be re-parsed.  'undefined' can be returned if the

+         * change range cannot be determined.  However, in that case, incremental parsing will

+         * not happen and the entire document will be re - parsed.

+         */

+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;

+>getChangeRange : (oldSnapshot: IScriptSnapshot) => TextChangeRange
+>oldSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>TextChangeRange : TextChangeRange
+    }

+    module ScriptSnapshot {

+>ScriptSnapshot : typeof ScriptSnapshot
+
+        function fromString(text: string): IScriptSnapshot;

+>fromString : (text: string) => IScriptSnapshot
+>text : string
+>IScriptSnapshot : IScriptSnapshot
+    }

+    interface PreProcessedFileInfo {

+>PreProcessedFileInfo : PreProcessedFileInfo
+
+        referencedFiles: FileReference[];

+>referencedFiles : FileReference[]
+>FileReference : FileReference
+
+        importedFiles: FileReference[];

+>importedFiles : FileReference[]
+>FileReference : FileReference
+
+        isLibFile: boolean;

+>isLibFile : boolean
+    }

+    interface Logger {

+>Logger : Logger
+
+        log(s: string): void;

+>log : (s: string) => void
+>s : string
+    }

+    interface LanguageServiceHost extends Logger {

+>LanguageServiceHost : LanguageServiceHost
+>Logger : Logger
+
+        getCompilationSettings(): CompilerOptions;

+>getCompilationSettings : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getScriptFileNames(): string[];

+>getScriptFileNames : () => string[]
+
+        getScriptVersion(fileName: string): string;

+>getScriptVersion : (fileName: string) => string
+>fileName : string
+
+        getScriptIsOpen(fileName: string): boolean;

+>getScriptIsOpen : (fileName: string) => boolean
+>fileName : string
+
+        getScriptSnapshot(fileName: string): IScriptSnapshot;

+>getScriptSnapshot : (fileName: string) => IScriptSnapshot
+>fileName : string
+>IScriptSnapshot : IScriptSnapshot
+
+        getLocalizedDiagnosticMessages?(): any;

+>getLocalizedDiagnosticMessages : () => any
+
+        getCancellationToken?(): CancellationToken;

+>getCancellationToken : () => CancellationToken
+>CancellationToken : CancellationToken
+
+        getCurrentDirectory(): string;

+>getCurrentDirectory : () => string
+
+        getDefaultLibFilename(options: CompilerOptions): string;

+>getDefaultLibFilename : (options: CompilerOptions) => string
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+    }

+    interface LanguageService {

+>LanguageService : LanguageService
+
+        cleanupSemanticCache(): void;

+>cleanupSemanticCache : () => void
+
+        getSyntacticDiagnostics(fileName: string): Diagnostic[];

+>getSyntacticDiagnostics : (fileName: string) => Diagnostic[]
+>fileName : string
+>Diagnostic : Diagnostic
+
+        getSemanticDiagnostics(fileName: string): Diagnostic[];

+>getSemanticDiagnostics : (fileName: string) => Diagnostic[]
+>fileName : string
+>Diagnostic : Diagnostic
+
+        getCompilerOptionsDiagnostics(): Diagnostic[];

+>getCompilerOptionsDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];

+>getSyntacticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[]
+>fileName : string
+>span : TextSpan
+>TextSpan : TextSpan
+>ClassifiedSpan : ClassifiedSpan
+
+        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];

+>getSemanticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[]
+>fileName : string
+>span : TextSpan
+>TextSpan : TextSpan
+>ClassifiedSpan : ClassifiedSpan
+
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;

+>getCompletionsAtPosition : (fileName: string, position: number) => CompletionInfo
+>fileName : string
+>position : number
+>CompletionInfo : CompletionInfo
+
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;

+>getCompletionEntryDetails : (fileName: string, position: number, entryName: string) => CompletionEntryDetails
+>fileName : string
+>position : number
+>entryName : string
+>CompletionEntryDetails : CompletionEntryDetails
+
+        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;

+>getQuickInfoAtPosition : (fileName: string, position: number) => QuickInfo
+>fileName : string
+>position : number
+>QuickInfo : QuickInfo
+
+        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;

+>getNameOrDottedNameSpan : (fileName: string, startPos: number, endPos: number) => TextSpan
+>fileName : string
+>startPos : number
+>endPos : number
+>TextSpan : TextSpan
+
+        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;

+>getBreakpointStatementAtPosition : (fileName: string, position: number) => TextSpan
+>fileName : string
+>position : number
+>TextSpan : TextSpan
+
+        getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;

+>getSignatureHelpItems : (fileName: string, position: number) => SignatureHelpItems
+>fileName : string
+>position : number
+>SignatureHelpItems : SignatureHelpItems
+
+        getRenameInfo(fileName: string, position: number): RenameInfo;

+>getRenameInfo : (fileName: string, position: number) => RenameInfo
+>fileName : string
+>position : number
+>RenameInfo : RenameInfo
+
+        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];

+>findRenameLocations : (fileName: string, position: number, findInStrings: boolean, findInComments: boolean) => RenameLocation[]
+>fileName : string
+>position : number
+>findInStrings : boolean
+>findInComments : boolean
+>RenameLocation : RenameLocation
+
+        getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];

+>getDefinitionAtPosition : (fileName: string, position: number) => DefinitionInfo[]
+>fileName : string
+>position : number
+>DefinitionInfo : DefinitionInfo
+
+        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];

+>getReferencesAtPosition : (fileName: string, position: number) => ReferenceEntry[]
+>fileName : string
+>position : number
+>ReferenceEntry : ReferenceEntry
+
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];

+>getOccurrencesAtPosition : (fileName: string, position: number) => ReferenceEntry[]
+>fileName : string
+>position : number
+>ReferenceEntry : ReferenceEntry
+
+        getNavigateToItems(searchValue: string): NavigateToItem[];

+>getNavigateToItems : (searchValue: string) => NavigateToItem[]
+>searchValue : string
+>NavigateToItem : NavigateToItem
+
+        getNavigationBarItems(fileName: string): NavigationBarItem[];

+>getNavigationBarItems : (fileName: string) => NavigationBarItem[]
+>fileName : string
+>NavigationBarItem : NavigationBarItem
+
+        getOutliningSpans(fileName: string): OutliningSpan[];

+>getOutliningSpans : (fileName: string) => OutliningSpan[]
+>fileName : string
+>OutliningSpan : OutliningSpan
+
+        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];

+>getTodoComments : (fileName: string, descriptors: TodoCommentDescriptor[]) => TodoComment[]
+>fileName : string
+>descriptors : TodoCommentDescriptor[]
+>TodoCommentDescriptor : TodoCommentDescriptor
+>TodoComment : TodoComment
+
+        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];

+>getBraceMatchingAtPosition : (fileName: string, position: number) => TextSpan[]
+>fileName : string
+>position : number
+>TextSpan : TextSpan
+
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number;

+>getIndentationAtPosition : (fileName: string, position: number, options: EditorOptions) => number
+>fileName : string
+>position : number
+>options : EditorOptions
+>EditorOptions : EditorOptions
+
+        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsForRange : (fileName: string, start: number, end: number, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>start : number
+>end : number
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsForDocument : (fileName: string, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsAfterKeystroke : (fileName: string, position: number, key: string, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>position : number
+>key : string
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getEmitOutput(fileName: string): EmitOutput;

+>getEmitOutput : (fileName: string) => EmitOutput
+>fileName : string
+>EmitOutput : EmitOutput
+
+        getSourceFile(filename: string): SourceFile;

+>getSourceFile : (filename: string) => SourceFile
+>filename : string
+>SourceFile : SourceFile
+
+        dispose(): void;

+>dispose : () => void
+    }

+    class TextSpan {

+>TextSpan : TextSpan
+
+        private _start;

+>_start : any
+
+        private _length;

+>_length : any
+
+        /**

+            * Creates a TextSpan instance beginning with the position Start and having the Length

+            * specified with length.

+            */

+        constructor(start: number, length: number);

+>start : number
+>length : number
+
+        toJSON(key: any): any;

+>toJSON : (key: any) => any
+>key : any
+
+        start(): number;

+>start : () => number
+
+        length(): number;

+>length : () => number
+
+        end(): number;

+>end : () => number
+
+        isEmpty(): boolean;

+>isEmpty : () => boolean
+
+        /**

+            * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less

+            * than End, otherwise false.

+            * @param position The position to check.

+            */

+        containsPosition(position: number): boolean;

+>containsPosition : (position: number) => boolean
+>position : number
+
+        /**

+            * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.

+            * @param span The span to check.

+            */

+        containsTextSpan(span: TextSpan): boolean;

+>containsTextSpan : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Determines whether the given span overlaps this span. Two spans are considered to overlap

+            * if they have positions in common and neither is empty. Empty spans do not overlap with any

+            * other span. Returns true if the spans overlap, false otherwise.

+            * @param span The span to check.

+            */

+        overlapsWith(span: TextSpan): boolean;

+>overlapsWith : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Returns the overlap with the given span, or undefined if there is no overlap.

+            * @param span The span to check.

+            */

+        overlap(span: TextSpan): TextSpan;

+>overlap : (span: TextSpan) => TextSpan
+>span : TextSpan
+>TextSpan : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Determines whether span intersects this span. Two spans are considered to

+            * intersect if they have positions in common or the end of one span

+            * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.

+            * @param The span to check.

+            */

+        intersectsWithTextSpan(span: TextSpan): boolean;

+>intersectsWithTextSpan : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        intersectsWith(start: number, length: number): boolean;

+>intersectsWith : (start: number, length: number) => boolean
+>start : number
+>length : number
+
+        /**

+            * Determines whether the given position intersects this span.

+            * A position is considered to intersect if it is between the start and

+            * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.

+            * @param position The position to check.

+            */

+        intersectsWithPosition(position: number): boolean;

+>intersectsWithPosition : (position: number) => boolean
+>position : number
+
+        /**

+            * Returns the intersection with the given span, or undefined if there is no intersection.

+            * @param span The span to check.

+            */

+        intersection(span: TextSpan): TextSpan;

+>intersection : (span: TextSpan) => TextSpan
+>span : TextSpan
+>TextSpan : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Creates a new TextSpan from the given start and end positions

+            * as opposed to a position and length.

+            */

+        static fromBounds(start: number, end: number): TextSpan;

+>fromBounds : (start: number, end: number) => TextSpan
+>start : number
+>end : number
+>TextSpan : TextSpan
+    }

+    class TextChangeRange {

+>TextChangeRange : TextChangeRange
+
+        static unchanged: TextChangeRange;

+>unchanged : TextChangeRange
+>TextChangeRange : TextChangeRange
+
+        private _span;

+>_span : any
+
+        private _newLength;

+>_newLength : any
+
+        /**

+            * Initializes a new instance of TextChangeRange.

+            */

+        constructor(span: TextSpan, newLength: number);

+>span : TextSpan
+>TextSpan : TextSpan
+>newLength : number
+
+        /**

+            * The span of text before the edit which is being changed

+            */

+        span(): TextSpan;

+>span : () => TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Width of the span after the edit.  A 0 here would represent a delete

+            */

+        newLength(): number;

+>newLength : () => number
+
+        newSpan(): TextSpan;

+>newSpan : () => TextSpan
+>TextSpan : TextSpan
+
+        isUnchanged(): boolean;

+>isUnchanged : () => boolean
+
+        /**

+            * Called to merge all the changes that occurred across several versions of a script snapshot

+            * into a single change.  i.e. if a user keeps making successive edits to a script we will

+            * have a text change from V1 to V2, V2 to V3, ..., Vn.

+            *

+            * This function will then merge those changes into a single change range valid between V1 and

+            * Vn.

+            */

+        static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;

+>collapseChangesAcrossMultipleVersions : (changes: TextChangeRange[]) => TextChangeRange
+>changes : TextChangeRange[]
+>TextChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+    }

+    interface ClassifiedSpan {

+>ClassifiedSpan : ClassifiedSpan
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        classificationType: string;

+>classificationType : string
+    }

+    interface NavigationBarItem {

+>NavigationBarItem : NavigationBarItem
+
+        text: string;

+>text : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        spans: TextSpan[];

+>spans : TextSpan[]
+>TextSpan : TextSpan
+
+        childItems: NavigationBarItem[];

+>childItems : NavigationBarItem[]
+>NavigationBarItem : NavigationBarItem
+
+        indent: number;

+>indent : number
+
+        bolded: boolean;

+>bolded : boolean
+
+        grayed: boolean;

+>grayed : boolean
+    }

+    interface TodoCommentDescriptor {

+>TodoCommentDescriptor : TodoCommentDescriptor
+
+        text: string;

+>text : string
+
+        priority: number;

+>priority : number
+    }

+    interface TodoComment {

+>TodoComment : TodoComment
+
+        descriptor: TodoCommentDescriptor;

+>descriptor : TodoCommentDescriptor
+>TodoCommentDescriptor : TodoCommentDescriptor
+
+        message: string;

+>message : string
+
+        position: number;

+>position : number
+    }

+    class TextChange {

+>TextChange : TextChange
+
+        span: TextSpan;

+>span : TextSpan
+>TextSpan : TextSpan
+
+        newText: string;

+>newText : string
+    }

+    interface RenameLocation {

+>RenameLocation : RenameLocation
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        fileName: string;

+>fileName : string
+    }

+    interface ReferenceEntry {

+>ReferenceEntry : ReferenceEntry
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        fileName: string;

+>fileName : string
+
+        isWriteAccess: boolean;

+>isWriteAccess : boolean
+    }

+    interface NavigateToItem {

+>NavigateToItem : NavigateToItem
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        matchKind: string;

+>matchKind : string
+
+        fileName: string;

+>fileName : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        containerName: string;

+>containerName : string
+
+        containerKind: string;

+>containerKind : string
+    }

+    interface EditorOptions {

+>EditorOptions : EditorOptions
+
+        IndentSize: number;

+>IndentSize : number
+
+        TabSize: number;

+>TabSize : number
+
+        NewLineCharacter: string;

+>NewLineCharacter : string
+
+        ConvertTabsToSpaces: boolean;

+>ConvertTabsToSpaces : boolean
+    }

+    interface FormatCodeOptions extends EditorOptions {

+>FormatCodeOptions : FormatCodeOptions
+>EditorOptions : EditorOptions
+
+        InsertSpaceAfterCommaDelimiter: boolean;

+>InsertSpaceAfterCommaDelimiter : boolean
+
+        InsertSpaceAfterSemicolonInForStatements: boolean;

+>InsertSpaceAfterSemicolonInForStatements : boolean
+
+        InsertSpaceBeforeAndAfterBinaryOperators: boolean;

+>InsertSpaceBeforeAndAfterBinaryOperators : boolean
+
+        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;

+>InsertSpaceAfterKeywordsInControlFlowStatements : boolean
+
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;

+>InsertSpaceAfterFunctionKeywordForAnonymousFunctions : boolean
+
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;

+>InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis : boolean
+
+        PlaceOpenBraceOnNewLineForFunctions: boolean;

+>PlaceOpenBraceOnNewLineForFunctions : boolean
+
+        PlaceOpenBraceOnNewLineForControlBlocks: boolean;

+>PlaceOpenBraceOnNewLineForControlBlocks : boolean
+    }

+    interface DefinitionInfo {

+>DefinitionInfo : DefinitionInfo
+
+        fileName: string;

+>fileName : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        kind: string;

+>kind : string
+
+        name: string;

+>name : string
+
+        containerKind: string;

+>containerKind : string
+
+        containerName: string;

+>containerName : string
+    }

+    enum SymbolDisplayPartKind {

+>SymbolDisplayPartKind : SymbolDisplayPartKind
+
+        aliasName = 0,

+>aliasName : SymbolDisplayPartKind
+
+        className = 1,

+>className : SymbolDisplayPartKind
+
+        enumName = 2,

+>enumName : SymbolDisplayPartKind
+
+        fieldName = 3,

+>fieldName : SymbolDisplayPartKind
+
+        interfaceName = 4,

+>interfaceName : SymbolDisplayPartKind
+
+        keyword = 5,

+>keyword : SymbolDisplayPartKind
+
+        lineBreak = 6,

+>lineBreak : SymbolDisplayPartKind
+
+        numericLiteral = 7,

+>numericLiteral : SymbolDisplayPartKind
+
+        stringLiteral = 8,

+>stringLiteral : SymbolDisplayPartKind
+
+        localName = 9,

+>localName : SymbolDisplayPartKind
+
+        methodName = 10,

+>methodName : SymbolDisplayPartKind
+
+        moduleName = 11,

+>moduleName : SymbolDisplayPartKind
+
+        operator = 12,

+>operator : SymbolDisplayPartKind
+
+        parameterName = 13,

+>parameterName : SymbolDisplayPartKind
+
+        propertyName = 14,

+>propertyName : SymbolDisplayPartKind
+
+        punctuation = 15,

+>punctuation : SymbolDisplayPartKind
+
+        space = 16,

+>space : SymbolDisplayPartKind
+
+        text = 17,

+>text : SymbolDisplayPartKind
+
+        typeParameterName = 18,

+>typeParameterName : SymbolDisplayPartKind
+
+        enumMemberName = 19,

+>enumMemberName : SymbolDisplayPartKind
+
+        functionName = 20,

+>functionName : SymbolDisplayPartKind
+
+        regularExpressionLiteral = 21,

+>regularExpressionLiteral : SymbolDisplayPartKind
+    }

+    interface SymbolDisplayPart {

+>SymbolDisplayPart : SymbolDisplayPart
+
+        text: string;

+>text : string
+
+        kind: string;

+>kind : string
+    }

+    interface QuickInfo {

+>QuickInfo : QuickInfo
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface RenameInfo {

+>RenameInfo : RenameInfo
+
+        canRename: boolean;

+>canRename : boolean
+
+        localizedErrorMessage: string;

+>localizedErrorMessage : string
+
+        displayName: string;

+>displayName : string
+
+        fullDisplayName: string;

+>fullDisplayName : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        triggerSpan: TextSpan;

+>triggerSpan : TextSpan
+>TextSpan : TextSpan
+    }

+    interface SignatureHelpParameter {

+>SignatureHelpParameter : SignatureHelpParameter
+
+        name: string;

+>name : string
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        isOptional: boolean;

+>isOptional : boolean
+    }

+    /**

+     * Represents a single signature to show in signature help.

+     * The id is used for subsequent calls into the language service to ask questions about the

+     * signature help item in the context of any documents that have been updated.  i.e. after

+     * an edit has happened, while signature help is still active, the host can ask important

+     * questions like 'what parameter is the user currently contained within?'.

+     */

+    interface SignatureHelpItem {

+>SignatureHelpItem : SignatureHelpItem
+
+        isVariadic: boolean;

+>isVariadic : boolean
+
+        prefixDisplayParts: SymbolDisplayPart[];

+>prefixDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        suffixDisplayParts: SymbolDisplayPart[];

+>suffixDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        separatorDisplayParts: SymbolDisplayPart[];

+>separatorDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        parameters: SignatureHelpParameter[];

+>parameters : SignatureHelpParameter[]
+>SignatureHelpParameter : SignatureHelpParameter
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    /**

+     * Represents a set of signature help items, and the preferred item that should be selected.

+     */

+    interface SignatureHelpItems {

+>SignatureHelpItems : SignatureHelpItems
+
+        items: SignatureHelpItem[];

+>items : SignatureHelpItem[]
+>SignatureHelpItem : SignatureHelpItem
+
+        applicableSpan: TextSpan;

+>applicableSpan : TextSpan
+>TextSpan : TextSpan
+
+        selectedItemIndex: number;

+>selectedItemIndex : number
+
+        argumentIndex: number;

+>argumentIndex : number
+
+        argumentCount: number;

+>argumentCount : number
+    }

+    interface CompletionInfo {

+>CompletionInfo : CompletionInfo
+
+        isMemberCompletion: boolean;

+>isMemberCompletion : boolean
+
+        entries: CompletionEntry[];

+>entries : CompletionEntry[]
+>CompletionEntry : CompletionEntry
+    }

+    interface CompletionEntry {

+>CompletionEntry : CompletionEntry
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+    }

+    interface CompletionEntryDetails {

+>CompletionEntryDetails : CompletionEntryDetails
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface OutliningSpan {

+>OutliningSpan : OutliningSpan
+
+        /** The span of the document to actually collapse. */

+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        /** The span of the document to display when the user hovers over the collapsed span. */

+        hintSpan: TextSpan;

+>hintSpan : TextSpan
+>TextSpan : TextSpan
+
+        /** The text to display in the editor for the collapsed region. */

+        bannerText: string;

+>bannerText : string
+
+        /**

+          * Whether or not this region should be automatically collapsed when

+          * the 'Collapse to Definitions' command is invoked.

+          */

+        autoCollapse: boolean;

+>autoCollapse : boolean
+    }

+    interface EmitOutput {

+>EmitOutput : EmitOutput
+
+        outputFiles: OutputFile[];

+>outputFiles : OutputFile[]
+>OutputFile : OutputFile
+
+        emitOutputStatus: EmitReturnStatus;

+>emitOutputStatus : EmitReturnStatus
+>EmitReturnStatus : EmitReturnStatus
+    }

+    const enum OutputFileType {

+>OutputFileType : OutputFileType
+
+        JavaScript = 0,

+>JavaScript : OutputFileType
+
+        SourceMap = 1,

+>SourceMap : OutputFileType
+
+        Declaration = 2,

+>Declaration : OutputFileType
+    }

+    interface OutputFile {

+>OutputFile : OutputFile
+
+        name: string;

+>name : string
+
+        writeByteOrderMark: boolean;

+>writeByteOrderMark : boolean
+
+        text: string;

+>text : string
+    }

+    const enum EndOfLineState {

+>EndOfLineState : EndOfLineState
+
+        Start = 0,

+>Start : EndOfLineState
+
+        InMultiLineCommentTrivia = 1,

+>InMultiLineCommentTrivia : EndOfLineState
+
+        InSingleQuoteStringLiteral = 2,

+>InSingleQuoteStringLiteral : EndOfLineState
+
+        InDoubleQuoteStringLiteral = 3,

+>InDoubleQuoteStringLiteral : EndOfLineState
+    }

+    enum TokenClass {

+>TokenClass : TokenClass
+
+        Punctuation = 0,

+>Punctuation : TokenClass
+
+        Keyword = 1,

+>Keyword : TokenClass
+
+        Operator = 2,

+>Operator : TokenClass
+
+        Comment = 3,

+>Comment : TokenClass
+
+        Whitespace = 4,

+>Whitespace : TokenClass
+
+        Identifier = 5,

+>Identifier : TokenClass
+
+        NumberLiteral = 6,

+>NumberLiteral : TokenClass
+
+        StringLiteral = 7,

+>StringLiteral : TokenClass
+
+        RegExpLiteral = 8,

+>RegExpLiteral : TokenClass
+    }

+    interface ClassificationResult {

+>ClassificationResult : ClassificationResult
+
+        finalLexState: EndOfLineState;

+>finalLexState : EndOfLineState
+>EndOfLineState : EndOfLineState
+
+        entries: ClassificationInfo[];

+>entries : ClassificationInfo[]
+>ClassificationInfo : ClassificationInfo
+    }

+    interface ClassificationInfo {

+>ClassificationInfo : ClassificationInfo
+
+        length: number;

+>length : number
+
+        classification: TokenClass;

+>classification : TokenClass
+>TokenClass : TokenClass
+    }

+    interface Classifier {

+>Classifier : Classifier
+
+        getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult;

+>getClassificationsForLine : (text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean) => ClassificationResult
+>text : string
+>lexState : EndOfLineState
+>EndOfLineState : EndOfLineState
+>classifyKeywordsInGenerics : boolean
+>ClassificationResult : ClassificationResult
+    }

+    interface DocumentRegistry {

+>DocumentRegistry : DocumentRegistry
+
+        acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile;

+>acquireDocument : (filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean) => SourceFile
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>SourceFile : SourceFile
+
+        updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;

+>updateDocument : (sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>textChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+>SourceFile : SourceFile
+
+        releaseDocument(filename: string, compilationSettings: CompilerOptions): void;

+>releaseDocument : (filename: string, compilationSettings: CompilerOptions) => void
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+    }

+    class ScriptElementKind {

+>ScriptElementKind : ScriptElementKind
+
+        static unknown: string;

+>unknown : string
+
+        static keyword: string;

+>keyword : string
+
+        static scriptElement: string;

+>scriptElement : string
+
+        static moduleElement: string;

+>moduleElement : string
+
+        static classElement: string;

+>classElement : string
+
+        static interfaceElement: string;

+>interfaceElement : string
+
+        static typeElement: string;

+>typeElement : string
+
+        static enumElement: string;

+>enumElement : string
+
+        static variableElement: string;

+>variableElement : string
+
+        static localVariableElement: string;

+>localVariableElement : string
+
+        static functionElement: string;

+>functionElement : string
+
+        static localFunctionElement: string;

+>localFunctionElement : string
+
+        static memberFunctionElement: string;

+>memberFunctionElement : string
+
+        static memberGetAccessorElement: string;

+>memberGetAccessorElement : string
+
+        static memberSetAccessorElement: string;

+>memberSetAccessorElement : string
+
+        static memberVariableElement: string;

+>memberVariableElement : string
+
+        static constructorImplementationElement: string;

+>constructorImplementationElement : string
+
+        static callSignatureElement: string;

+>callSignatureElement : string
+
+        static indexSignatureElement: string;

+>indexSignatureElement : string
+
+        static constructSignatureElement: string;

+>constructSignatureElement : string
+
+        static parameterElement: string;

+>parameterElement : string
+
+        static typeParameterElement: string;

+>typeParameterElement : string
+
+        static primitiveType: string;

+>primitiveType : string
+
+        static label: string;

+>label : string
+
+        static alias: string;

+>alias : string
+
+        static constElement: string;

+>constElement : string
+
+        static letElement: string;

+>letElement : string
+    }

+    class ScriptElementKindModifier {

+>ScriptElementKindModifier : ScriptElementKindModifier
+
+        static none: string;

+>none : string
+
+        static publicMemberModifier: string;

+>publicMemberModifier : string
+
+        static privateMemberModifier: string;

+>privateMemberModifier : string
+
+        static protectedMemberModifier: string;

+>protectedMemberModifier : string
+
+        static exportedModifier: string;

+>exportedModifier : string
+
+        static ambientModifier: string;

+>ambientModifier : string
+
+        static staticModifier: string;

+>staticModifier : string
+    }

+    class ClassificationTypeNames {

+>ClassificationTypeNames : ClassificationTypeNames
+
+        static comment: string;

+>comment : string
+
+        static identifier: string;

+>identifier : string
+
+        static keyword: string;

+>keyword : string
+
+        static numericLiteral: string;

+>numericLiteral : string
+
+        static operator: string;

+>operator : string
+
+        static stringLiteral: string;

+>stringLiteral : string
+
+        static whiteSpace: string;

+>whiteSpace : string
+
+        static text: string;

+>text : string
+
+        static punctuation: string;

+>punctuation : string
+
+        static className: string;

+>className : string
+
+        static enumName: string;

+>enumName : string
+
+        static interfaceName: string;

+>interfaceName : string
+
+        static moduleName: string;

+>moduleName : string
+
+        static typeParameterName: string;

+>typeParameterName : string
+
+        static typeAlias: string;

+>typeAlias : string
+    }

+    interface DisplayPartsSymbolWriter extends SymbolWriter {

+>DisplayPartsSymbolWriter : DisplayPartsSymbolWriter
+>SymbolWriter : SymbolWriter
+
+        displayParts(): SymbolDisplayPart[];

+>displayParts : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    function displayPartsToString(displayParts: SymbolDisplayPart[]): string;

+>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string
+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+    function getDefaultCompilerOptions(): CompilerOptions;

+>getDefaultCompilerOptions : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+    class OperationCanceledException {

+>OperationCanceledException : OperationCanceledException
+    }

+    class CancellationTokenObject {

+>CancellationTokenObject : CancellationTokenObject
+
+        private cancellationToken;

+>cancellationToken : any
+
+        static None: CancellationTokenObject;

+>None : CancellationTokenObject
+>CancellationTokenObject : CancellationTokenObject
+
+        constructor(cancellationToken: CancellationToken);

+>cancellationToken : CancellationToken
+>CancellationToken : CancellationToken
+
+        isCancellationRequested(): boolean;

+>isCancellationRequested : () => boolean
+
+        throwIfCancellationRequested(): void;

+>throwIfCancellationRequested : () => void
+    }

+    function createDocumentRegistry(): DocumentRegistry;

+>createDocumentRegistry : () => DocumentRegistry
+>DocumentRegistry : DocumentRegistry
+
+    function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;

+>preProcessFile : (sourceText: string, readImportFiles?: boolean) => PreProcessedFileInfo
+>sourceText : string
+>readImportFiles : boolean
+>PreProcessedFileInfo : PreProcessedFileInfo
+
+    function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService;

+>createLanguageService : (host: LanguageServiceHost, documentRegistry: DocumentRegistry) => LanguageService
+>host : LanguageServiceHost
+>LanguageServiceHost : LanguageServiceHost
+>documentRegistry : DocumentRegistry
+>DocumentRegistry : DocumentRegistry
+>LanguageService : LanguageService
+
+    function createClassifier(host: Logger): Classifier;

+>createClassifier : (host: Logger) => Classifier
+>host : Logger
+>Logger : Logger
+>Classifier : Classifier
+}

+
diff --git a/tests/baselines/reference/APISample_standalone_compile.js b/tests/baselines/reference/APISample_standalone_compile.js
new file mode 100644
index 00000000000..6ba3d4f6b1b
--- /dev/null
+++ b/tests/baselines/reference/APISample_standalone_compile.js
@@ -0,0 +1,1862 @@
+//// [tests/cases/compiler/APISample_standalone_compile.ts] ////
+
+//// [APISample_standalone_compile.ts]
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
+//// [typescriptServices.d.ts]
+/*! *****************************************************************************
+Copyright (c) Microsoft Corporation. All rights reserved. 
+Licensed under the Apache License, Version 2.0 (the "License"); you may not use
+this file except in compliance with the License. You may obtain a copy of the
+License at http://www.apache.org/licenses/LICENSE-2.0  
+ 
+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY
+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED
+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 
+MERCHANTABLITY OR NON-INFRINGEMENT. 
+ 
+See the Apache Version 2.0 License for specific language governing permissions
+and limitations under the License.
+***************************************************************************** */
+
+declare module ts {
+    interface Map<T> {
+        [index: string]: T;
+    }
+    interface TextRange {
+        pos: number;
+        end: number;
+    }
+    const enum SyntaxKind {
+        Unknown = 0,
+        EndOfFileToken = 1,
+        SingleLineCommentTrivia = 2,
+        MultiLineCommentTrivia = 3,
+        NewLineTrivia = 4,
+        WhitespaceTrivia = 5,
+        NumericLiteral = 6,
+        StringLiteral = 7,
+        RegularExpressionLiteral = 8,
+        NoSubstitutionTemplateLiteral = 9,
+        TemplateHead = 10,
+        TemplateMiddle = 11,
+        TemplateTail = 12,
+        OpenBraceToken = 13,
+        CloseBraceToken = 14,
+        OpenParenToken = 15,
+        CloseParenToken = 16,
+        OpenBracketToken = 17,
+        CloseBracketToken = 18,
+        DotToken = 19,
+        DotDotDotToken = 20,
+        SemicolonToken = 21,
+        CommaToken = 22,
+        LessThanToken = 23,
+        GreaterThanToken = 24,
+        LessThanEqualsToken = 25,
+        GreaterThanEqualsToken = 26,
+        EqualsEqualsToken = 27,
+        ExclamationEqualsToken = 28,
+        EqualsEqualsEqualsToken = 29,
+        ExclamationEqualsEqualsToken = 30,
+        EqualsGreaterThanToken = 31,
+        PlusToken = 32,
+        MinusToken = 33,
+        AsteriskToken = 34,
+        SlashToken = 35,
+        PercentToken = 36,
+        PlusPlusToken = 37,
+        MinusMinusToken = 38,
+        LessThanLessThanToken = 39,
+        GreaterThanGreaterThanToken = 40,
+        GreaterThanGreaterThanGreaterThanToken = 41,
+        AmpersandToken = 42,
+        BarToken = 43,
+        CaretToken = 44,
+        ExclamationToken = 45,
+        TildeToken = 46,
+        AmpersandAmpersandToken = 47,
+        BarBarToken = 48,
+        QuestionToken = 49,
+        ColonToken = 50,
+        EqualsToken = 51,
+        PlusEqualsToken = 52,
+        MinusEqualsToken = 53,
+        AsteriskEqualsToken = 54,
+        SlashEqualsToken = 55,
+        PercentEqualsToken = 56,
+        LessThanLessThanEqualsToken = 57,
+        GreaterThanGreaterThanEqualsToken = 58,
+        GreaterThanGreaterThanGreaterThanEqualsToken = 59,
+        AmpersandEqualsToken = 60,
+        BarEqualsToken = 61,
+        CaretEqualsToken = 62,
+        Identifier = 63,
+        BreakKeyword = 64,
+        CaseKeyword = 65,
+        CatchKeyword = 66,
+        ClassKeyword = 67,
+        ConstKeyword = 68,
+        ContinueKeyword = 69,
+        DebuggerKeyword = 70,
+        DefaultKeyword = 71,
+        DeleteKeyword = 72,
+        DoKeyword = 73,
+        ElseKeyword = 74,
+        EnumKeyword = 75,
+        ExportKeyword = 76,
+        ExtendsKeyword = 77,
+        FalseKeyword = 78,
+        FinallyKeyword = 79,
+        ForKeyword = 80,
+        FunctionKeyword = 81,
+        IfKeyword = 82,
+        ImportKeyword = 83,
+        InKeyword = 84,
+        InstanceOfKeyword = 85,
+        NewKeyword = 86,
+        NullKeyword = 87,
+        ReturnKeyword = 88,
+        SuperKeyword = 89,
+        SwitchKeyword = 90,
+        ThisKeyword = 91,
+        ThrowKeyword = 92,
+        TrueKeyword = 93,
+        TryKeyword = 94,
+        TypeOfKeyword = 95,
+        VarKeyword = 96,
+        VoidKeyword = 97,
+        WhileKeyword = 98,
+        WithKeyword = 99,
+        ImplementsKeyword = 100,
+        InterfaceKeyword = 101,
+        LetKeyword = 102,
+        PackageKeyword = 103,
+        PrivateKeyword = 104,
+        ProtectedKeyword = 105,
+        PublicKeyword = 106,
+        StaticKeyword = 107,
+        YieldKeyword = 108,
+        AnyKeyword = 109,
+        BooleanKeyword = 110,
+        ConstructorKeyword = 111,
+        DeclareKeyword = 112,
+        GetKeyword = 113,
+        ModuleKeyword = 114,
+        RequireKeyword = 115,
+        NumberKeyword = 116,
+        SetKeyword = 117,
+        StringKeyword = 118,
+        TypeKeyword = 119,
+        QualifiedName = 120,
+        ComputedPropertyName = 121,
+        TypeParameter = 122,
+        Parameter = 123,
+        Property = 124,
+        Method = 125,
+        Constructor = 126,
+        GetAccessor = 127,
+        SetAccessor = 128,
+        CallSignature = 129,
+        ConstructSignature = 130,
+        IndexSignature = 131,
+        TypeReference = 132,
+        FunctionType = 133,
+        ConstructorType = 134,
+        TypeQuery = 135,
+        TypeLiteral = 136,
+        ArrayType = 137,
+        TupleType = 138,
+        UnionType = 139,
+        ParenthesizedType = 140,
+        ArrayLiteralExpression = 141,
+        ObjectLiteralExpression = 142,
+        PropertyAccessExpression = 143,
+        ElementAccessExpression = 144,
+        CallExpression = 145,
+        NewExpression = 146,
+        TaggedTemplateExpression = 147,
+        TypeAssertionExpression = 148,
+        ParenthesizedExpression = 149,
+        FunctionExpression = 150,
+        ArrowFunction = 151,
+        DeleteExpression = 152,
+        TypeOfExpression = 153,
+        VoidExpression = 154,
+        PrefixUnaryExpression = 155,
+        PostfixUnaryExpression = 156,
+        BinaryExpression = 157,
+        ConditionalExpression = 158,
+        TemplateExpression = 159,
+        YieldExpression = 160,
+        OmittedExpression = 161,
+        TemplateSpan = 162,
+        Block = 163,
+        VariableStatement = 164,
+        EmptyStatement = 165,
+        ExpressionStatement = 166,
+        IfStatement = 167,
+        DoStatement = 168,
+        WhileStatement = 169,
+        ForStatement = 170,
+        ForInStatement = 171,
+        ContinueStatement = 172,
+        BreakStatement = 173,
+        ReturnStatement = 174,
+        WithStatement = 175,
+        SwitchStatement = 176,
+        LabeledStatement = 177,
+        ThrowStatement = 178,
+        TryStatement = 179,
+        TryBlock = 180,
+        FinallyBlock = 181,
+        DebuggerStatement = 182,
+        VariableDeclaration = 183,
+        FunctionDeclaration = 184,
+        ClassDeclaration = 185,
+        InterfaceDeclaration = 186,
+        TypeAliasDeclaration = 187,
+        EnumDeclaration = 188,
+        ModuleDeclaration = 189,
+        ModuleBlock = 190,
+        ImportDeclaration = 191,
+        ExportAssignment = 192,
+        ExternalModuleReference = 193,
+        CaseClause = 194,
+        DefaultClause = 195,
+        HeritageClause = 196,
+        CatchClause = 197,
+        PropertyAssignment = 198,
+        ShorthandPropertyAssignment = 199,
+        EnumMember = 200,
+        SourceFile = 201,
+        Program = 202,
+        SyntaxList = 203,
+        Count = 204,
+        FirstAssignment = 51,
+        LastAssignment = 62,
+        FirstReservedWord = 64,
+        LastReservedWord = 99,
+        FirstKeyword = 64,
+        LastKeyword = 119,
+        FirstFutureReservedWord = 100,
+        LastFutureReservedWord = 108,
+        FirstTypeNode = 132,
+        LastTypeNode = 140,
+        FirstPunctuation = 13,
+        LastPunctuation = 62,
+        FirstToken = 0,
+        LastToken = 119,
+        FirstTriviaToken = 2,
+        LastTriviaToken = 5,
+        FirstLiteralToken = 6,
+        LastLiteralToken = 9,
+        FirstTemplateToken = 9,
+        LastTemplateToken = 12,
+        FirstOperator = 21,
+        LastOperator = 62,
+        FirstBinaryOperator = 23,
+        LastBinaryOperator = 62,
+        FirstNode = 120,
+    }
+    const enum NodeFlags {
+        Export = 1,
+        Ambient = 2,
+        Public = 16,
+        Private = 32,
+        Protected = 64,
+        Static = 128,
+        MultiLine = 256,
+        Synthetic = 512,
+        DeclarationFile = 1024,
+        Let = 2048,
+        Const = 4096,
+        OctalLiteral = 8192,
+        Modifier = 243,
+        AccessibilityModifier = 112,
+        BlockScoped = 6144,
+    }
+    const enum ParserContextFlags {
+        StrictMode = 1,
+        DisallowIn = 2,
+        Yield = 4,
+        GeneratorParameter = 8,
+        ContainsError = 16,
+        HasPropagatedChildContainsErrorFlag = 32,
+    }
+    interface Node extends TextRange {
+        kind: SyntaxKind;
+        flags: NodeFlags;
+        parserContextFlags?: ParserContextFlags;
+        id?: number;
+        parent?: Node;
+        symbol?: Symbol;
+        locals?: SymbolTable;
+        nextContainer?: Node;
+        localSymbol?: Symbol;
+        modifiers?: ModifiersArray;
+    }
+    interface NodeArray<T> extends Array<T>, TextRange {
+        hasTrailingComma?: boolean;
+    }
+    interface ModifiersArray extends NodeArray<Node> {
+        flags: number;
+    }
+    interface Identifier extends PrimaryExpression {
+        text: string;
+    }
+    interface QualifiedName extends Node {
+        left: EntityName;
+        right: Identifier;
+    }
+    type EntityName = Identifier | QualifiedName;
+    type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName;
+    interface Declaration extends Node {
+        _declarationBrand: any;
+        name?: DeclarationName;
+    }
+    interface ComputedPropertyName extends Node {
+        expression: Expression;
+    }
+    interface TypeParameterDeclaration extends Declaration {
+        name: Identifier;
+        constraint?: TypeNode;
+        expression?: Expression;
+    }
+    interface SignatureDeclaration extends Declaration {
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        parameters: NodeArray<ParameterDeclaration>;
+        type?: TypeNode;
+    }
+    interface VariableDeclaration extends Declaration {
+        name: Identifier;
+        type?: TypeNode;
+        initializer?: Expression;
+    }
+    interface ParameterDeclaration extends Declaration {
+        dotDotDotToken?: Node;
+        name: Identifier;
+        questionToken?: Node;
+        type?: TypeNode | StringLiteralExpression;
+        initializer?: Expression;
+    }
+    interface PropertyDeclaration extends Declaration, ClassElement {
+        _propertyDeclarationBrand: any;
+        questionToken?: Node;
+        type?: TypeNode;
+        initializer?: Expression;
+    }
+    type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration;
+    type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration;
+    interface ObjectLiteralElement extends Declaration {
+        _objectLiteralBrandBrand: any;
+    }
+    interface ShorthandPropertyAssignment extends ObjectLiteralElement {
+        name: Identifier;
+        questionToken?: Node;
+    }
+    interface PropertyAssignment extends ObjectLiteralElement {
+        _propertyAssignmentBrand: any;
+        name: DeclarationName;
+        questionToken?: Node;
+        initializer: Expression;
+    }
+    /**
+     * Several node kinds share function-like features such as a signature,
+     * a name, and a body. These nodes should extend FunctionLikeDeclaration.
+     * Examples:
+     *  FunctionDeclaration
+     *  MethodDeclaration
+     *  AccessorDeclaration
+     */
+    interface FunctionLikeDeclaration extends SignatureDeclaration {
+        _functionLikeDeclarationBrand: any;
+        asteriskToken?: Node;
+        questionToken?: Node;
+        body?: Block | Expression;
+    }
+    interface FunctionDeclaration extends FunctionLikeDeclaration, Statement {
+        name: Identifier;
+        body?: Block;
+    }
+    interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
+        body?: Block;
+    }
+    interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {
+        body?: Block;
+    }
+    interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {
+        _accessorDeclarationBrand: any;
+        body: Block;
+    }
+    interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement {
+        _indexSignatureDeclarationBrand: any;
+    }
+    interface TypeNode extends Node {
+        _typeNodeBrand: any;
+    }
+    interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {
+        _functionOrConstructorTypeNodeBrand: any;
+    }
+    interface TypeReferenceNode extends TypeNode {
+        typeName: EntityName;
+        typeArguments?: NodeArray<TypeNode>;
+    }
+    interface TypeQueryNode extends TypeNode {
+        exprName: EntityName;
+    }
+    interface TypeLiteralNode extends TypeNode, Declaration {
+        members: NodeArray<Node>;
+    }
+    interface ArrayTypeNode extends TypeNode {
+        elementType: TypeNode;
+    }
+    interface TupleTypeNode extends TypeNode {
+        elementTypes: NodeArray<TypeNode>;
+    }
+    interface UnionTypeNode extends TypeNode {
+        types: NodeArray<TypeNode>;
+    }
+    interface ParenthesizedTypeNode extends TypeNode {
+        type: TypeNode;
+    }
+    interface Expression extends Node {
+        _expressionBrand: any;
+        contextualType?: Type;
+    }
+    interface UnaryExpression extends Expression {
+        _unaryExpressionBrand: any;
+    }
+    interface PrefixUnaryExpression extends UnaryExpression {
+        operator: SyntaxKind;
+        operand: UnaryExpression;
+    }
+    interface PostfixUnaryExpression extends PostfixExpression {
+        operand: LeftHandSideExpression;
+        operator: SyntaxKind;
+    }
+    interface PostfixExpression extends UnaryExpression {
+        _postfixExpressionBrand: any;
+    }
+    interface LeftHandSideExpression extends PostfixExpression {
+        _leftHandSideExpressionBrand: any;
+    }
+    interface MemberExpression extends LeftHandSideExpression {
+        _memberExpressionBrand: any;
+    }
+    interface PrimaryExpression extends MemberExpression {
+        _primaryExpressionBrand: any;
+    }
+    interface DeleteExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface TypeOfExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface VoidExpression extends UnaryExpression {
+        expression: UnaryExpression;
+    }
+    interface YieldExpression extends Expression {
+        asteriskToken?: Node;
+        expression: Expression;
+    }
+    interface BinaryExpression extends Expression {
+        left: Expression;
+        operator: SyntaxKind;
+        right: Expression;
+    }
+    interface ConditionalExpression extends Expression {
+        condition: Expression;
+        whenTrue: Expression;
+        whenFalse: Expression;
+    }
+    interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {
+        name?: Identifier;
+        body: Block | Expression;
+    }
+    interface LiteralExpression extends PrimaryExpression {
+        text: string;
+        isUnterminated?: boolean;
+    }
+    interface StringLiteralExpression extends LiteralExpression {
+        _stringLiteralExpressionBrand: any;
+    }
+    interface TemplateExpression extends PrimaryExpression {
+        head: LiteralExpression;
+        templateSpans: NodeArray<TemplateSpan>;
+    }
+    interface TemplateSpan extends Node {
+        expression: Expression;
+        literal: LiteralExpression;
+    }
+    interface ParenthesizedExpression extends PrimaryExpression {
+        expression: Expression;
+    }
+    interface ArrayLiteralExpression extends PrimaryExpression {
+        elements: NodeArray<Expression>;
+    }
+    interface ObjectLiteralExpression extends PrimaryExpression, Declaration {
+        properties: NodeArray<ObjectLiteralElement>;
+    }
+    interface PropertyAccessExpression extends MemberExpression {
+        expression: LeftHandSideExpression;
+        name: Identifier;
+    }
+    interface ElementAccessExpression extends MemberExpression {
+        expression: LeftHandSideExpression;
+        argumentExpression?: Expression;
+    }
+    interface CallExpression extends LeftHandSideExpression {
+        expression: LeftHandSideExpression;
+        typeArguments?: NodeArray<TypeNode>;
+        arguments: NodeArray<Expression>;
+    }
+    interface NewExpression extends CallExpression, PrimaryExpression {
+    }
+    interface TaggedTemplateExpression extends MemberExpression {
+        tag: LeftHandSideExpression;
+        template: LiteralExpression | TemplateExpression;
+    }
+    type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;
+    interface TypeAssertion extends UnaryExpression {
+        type: TypeNode;
+        expression: UnaryExpression;
+    }
+    interface Statement extends Node, ModuleElement {
+        _statementBrand: any;
+    }
+    interface Block extends Statement {
+        statements: NodeArray<Statement>;
+    }
+    interface VariableStatement extends Statement {
+        declarations: NodeArray<VariableDeclaration>;
+    }
+    interface ExpressionStatement extends Statement {
+        expression: Expression;
+    }
+    interface IfStatement extends Statement {
+        expression: Expression;
+        thenStatement: Statement;
+        elseStatement?: Statement;
+    }
+    interface IterationStatement extends Statement {
+        statement: Statement;
+    }
+    interface DoStatement extends IterationStatement {
+        expression: Expression;
+    }
+    interface WhileStatement extends IterationStatement {
+        expression: Expression;
+    }
+    interface ForStatement extends IterationStatement {
+        declarations?: NodeArray<VariableDeclaration>;
+        initializer?: Expression;
+        condition?: Expression;
+        iterator?: Expression;
+    }
+    interface ForInStatement extends IterationStatement {
+        declarations?: NodeArray<VariableDeclaration>;
+        variable?: Expression;
+        expression: Expression;
+    }
+    interface BreakOrContinueStatement extends Statement {
+        label?: Identifier;
+    }
+    interface ReturnStatement extends Statement {
+        expression?: Expression;
+    }
+    interface WithStatement extends Statement {
+        expression: Expression;
+        statement: Statement;
+    }
+    interface SwitchStatement extends Statement {
+        expression: Expression;
+        clauses: NodeArray<CaseOrDefaultClause>;
+    }
+    interface CaseClause extends Node {
+        expression?: Expression;
+        statements: NodeArray<Statement>;
+    }
+    interface DefaultClause extends Node {
+        statements: NodeArray<Statement>;
+    }
+    type CaseOrDefaultClause = CaseClause | DefaultClause;
+    interface LabeledStatement extends Statement {
+        label: Identifier;
+        statement: Statement;
+    }
+    interface ThrowStatement extends Statement {
+        expression: Expression;
+    }
+    interface TryStatement extends Statement {
+        tryBlock: Block;
+        catchClause?: CatchClause;
+        finallyBlock?: Block;
+    }
+    interface CatchClause extends Declaration {
+        name: Identifier;
+        type?: TypeNode;
+        block: Block;
+    }
+    interface ModuleElement extends Node {
+        _moduleElementBrand: any;
+    }
+    interface ClassDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        heritageClauses?: NodeArray<HeritageClause>;
+        members: NodeArray<ClassElement>;
+    }
+    interface ClassElement extends Declaration {
+        _classElementBrand: any;
+    }
+    interface InterfaceDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        typeParameters?: NodeArray<TypeParameterDeclaration>;
+        heritageClauses?: NodeArray<HeritageClause>;
+        members: NodeArray<Declaration>;
+    }
+    interface HeritageClause extends Node {
+        token: SyntaxKind;
+        types?: NodeArray<TypeReferenceNode>;
+    }
+    interface TypeAliasDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        type: TypeNode;
+    }
+    interface EnumMember extends Declaration {
+        name: DeclarationName;
+        initializer?: Expression;
+    }
+    interface EnumDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        members: NodeArray<EnumMember>;
+    }
+    interface ModuleDeclaration extends Declaration, ModuleElement {
+        name: Identifier | LiteralExpression;
+        body: ModuleBlock | ModuleDeclaration;
+    }
+    interface ModuleBlock extends Node, ModuleElement {
+        statements: NodeArray<ModuleElement>;
+    }
+    interface ImportDeclaration extends Declaration, ModuleElement {
+        name: Identifier;
+        moduleReference: EntityName | ExternalModuleReference;
+    }
+    interface ExternalModuleReference extends Node {
+        expression?: Expression;
+    }
+    interface ExportAssignment extends Statement, ModuleElement {
+        exportName: Identifier;
+    }
+    interface FileReference extends TextRange {
+        filename: string;
+    }
+    interface CommentRange extends TextRange {
+        hasTrailingNewLine?: boolean;
+    }
+    interface SourceFile extends Declaration {
+        statements: NodeArray<ModuleElement>;
+        endOfFileToken: Node;
+        filename: string;
+        text: string;
+        getLineAndCharacterFromPosition(position: number): LineAndCharacter;
+        getPositionFromLineAndCharacter(line: number, character: number): number;
+        getLineStarts(): number[];
+        amdDependencies: string[];
+        amdModuleName: string;
+        referencedFiles: FileReference[];
+        referenceDiagnostics: Diagnostic[];
+        parseDiagnostics: Diagnostic[];
+        grammarDiagnostics: Diagnostic[];
+        getSyntacticDiagnostics(): Diagnostic[];
+        semanticDiagnostics: Diagnostic[];
+        hasNoDefaultLib: boolean;
+        externalModuleIndicator: Node;
+        nodeCount: number;
+        identifierCount: number;
+        symbolCount: number;
+        isOpen: boolean;
+        version: string;
+        languageVersion: ScriptTarget;
+        identifiers: Map<string>;
+    }
+    interface Program {
+        getSourceFile(filename: string): SourceFile;
+        getSourceFiles(): SourceFile[];
+        getCompilerOptions(): CompilerOptions;
+        getCompilerHost(): CompilerHost;
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];
+        getGlobalDiagnostics(): Diagnostic[];
+        getTypeChecker(fullTypeCheckMode: boolean): TypeChecker;
+        getCommonSourceDirectory(): string;
+    }
+    interface SourceMapSpan {
+        emittedLine: number;
+        emittedColumn: number;
+        sourceLine: number;
+        sourceColumn: number;
+        nameIndex?: number;
+        sourceIndex: number;
+    }
+    interface SourceMapData {
+        sourceMapFilePath: string;
+        jsSourceMappingURL: string;
+        sourceMapFile: string;
+        sourceMapSourceRoot: string;
+        sourceMapSources: string[];
+        inputSourceFileNames: string[];
+        sourceMapNames?: string[];
+        sourceMapMappings: string;
+        sourceMapDecodedMappings: SourceMapSpan[];
+    }
+    enum EmitReturnStatus {
+        Succeeded = 0,
+        AllOutputGenerationSkipped = 1,
+        JSGeneratedWithSemanticErrors = 2,
+        DeclarationGenerationSkipped = 3,
+        EmitErrorsEncountered = 4,
+        CompilerOptionsErrors = 5,
+    }
+    interface EmitResult {
+        emitResultStatus: EmitReturnStatus;
+        diagnostics: Diagnostic[];
+        sourceMaps: SourceMapData[];
+    }
+    interface TypeChecker {
+        getProgram(): Program;
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];
+        getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[];
+        getGlobalDiagnostics(): Diagnostic[];
+        getNodeCount(): number;
+        getIdentifierCount(): number;
+        getSymbolCount(): number;
+        getTypeCount(): number;
+        emitFiles(targetSourceFile?: SourceFile): EmitResult;
+        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
+        getDeclaredTypeOfSymbol(symbol: Symbol): Type;
+        getPropertiesOfType(type: Type): Symbol[];
+        getPropertyOfType(type: Type, propertyName: string): Symbol;
+        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
+        getIndexTypeOfType(type: Type, kind: IndexKind): Type;
+        getReturnTypeOfSignature(signature: Signature): Type;
+        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
+        getSymbolAtLocation(node: Node): Symbol;
+        getShorthandAssignmentValueSymbol(location: Node): Symbol;
+        getTypeAtLocation(node: Node): Type;
+        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
+        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
+        getSymbolDisplayBuilder(): SymbolDisplayBuilder;
+        getFullyQualifiedName(symbol: Symbol): string;
+        getAugmentedPropertiesOfType(type: Type): Symbol[];
+        getRootSymbols(symbol: Symbol): Symbol[];
+        getContextualType(node: Expression): Type;
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        isUndefinedSymbol(symbol: Symbol): boolean;
+        isArgumentsSymbol(symbol: Symbol): boolean;
+        isEmitBlocked(sourceFile?: SourceFile): boolean;
+        getEnumMemberValue(node: EnumMember): number;
+        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
+        getAliasedSymbol(symbol: Symbol): Symbol;
+    }
+    interface SymbolDisplayBuilder {
+        buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
+        buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+        buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
+    }
+    interface SymbolWriter {
+        writeKeyword(text: string): void;
+        writeOperator(text: string): void;
+        writePunctuation(text: string): void;
+        writeSpace(text: string): void;
+        writeStringLiteral(text: string): void;
+        writeParameter(text: string): void;
+        writeSymbol(text: string, symbol: Symbol): void;
+        writeLine(): void;
+        increaseIndent(): void;
+        decreaseIndent(): void;
+        clear(): void;
+        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
+    }
+    const enum TypeFormatFlags {
+        None = 0,
+        WriteArrayAsGenericType = 1,
+        UseTypeOfFunction = 2,
+        NoTruncation = 4,
+        WriteArrowStyleSignature = 8,
+        WriteOwnNameForAnyLike = 16,
+        WriteTypeArgumentsOfSignature = 32,
+        InElementType = 64,
+    }
+    const enum SymbolFormatFlags {
+        None = 0,
+        WriteTypeParametersOrArguments = 1,
+        UseOnlyExternalAliasing = 2,
+    }
+    const enum SymbolAccessibility {
+        Accessible = 0,
+        NotAccessible = 1,
+        CannotBeNamed = 2,
+    }
+    interface SymbolVisibilityResult {
+        accessibility: SymbolAccessibility;
+        aliasesToMakeVisible?: ImportDeclaration[];
+        errorSymbolName?: string;
+        errorNode?: Node;
+    }
+    interface SymbolAccessiblityResult extends SymbolVisibilityResult {
+        errorModuleName?: string;
+    }
+    interface EmitResolver {
+        getProgram(): Program;
+        getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string;
+        getExpressionNamePrefix(node: Identifier): string;
+        getExportAssignmentName(node: SourceFile): string;
+        isReferencedImportDeclaration(node: ImportDeclaration): boolean;
+        isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean;
+        getNodeCheckFlags(node: Node): NodeCheckFlags;
+        getEnumMemberValue(node: EnumMember): number;
+        hasSemanticErrors(sourceFile?: SourceFile): boolean;
+        isDeclarationVisible(node: Declaration): boolean;
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
+        writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;
+        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;
+        getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number;
+        isEmitBlocked(sourceFile?: SourceFile): boolean;
+    }
+    const enum SymbolFlags {
+        FunctionScopedVariable = 1,
+        BlockScopedVariable = 2,
+        Property = 4,
+        EnumMember = 8,
+        Function = 16,
+        Class = 32,
+        Interface = 64,
+        ConstEnum = 128,
+        RegularEnum = 256,
+        ValueModule = 512,
+        NamespaceModule = 1024,
+        TypeLiteral = 2048,
+        ObjectLiteral = 4096,
+        Method = 8192,
+        Constructor = 16384,
+        GetAccessor = 32768,
+        SetAccessor = 65536,
+        CallSignature = 131072,
+        ConstructSignature = 262144,
+        IndexSignature = 524288,
+        TypeParameter = 1048576,
+        TypeAlias = 2097152,
+        ExportValue = 4194304,
+        ExportType = 8388608,
+        ExportNamespace = 16777216,
+        Import = 33554432,
+        Instantiated = 67108864,
+        Merged = 134217728,
+        Transient = 268435456,
+        Prototype = 536870912,
+        UnionProperty = 1073741824,
+        Enum = 384,
+        Variable = 3,
+        Value = 107455,
+        Type = 3152352,
+        Namespace = 1536,
+        Module = 1536,
+        Accessor = 98304,
+        Signature = 917504,
+        FunctionScopedVariableExcludes = 107454,
+        BlockScopedVariableExcludes = 107455,
+        ParameterExcludes = 107455,
+        PropertyExcludes = 107455,
+        EnumMemberExcludes = 107455,
+        FunctionExcludes = 106927,
+        ClassExcludes = 3258879,
+        InterfaceExcludes = 3152288,
+        RegularEnumExcludes = 3258623,
+        ConstEnumExcludes = 3259263,
+        ValueModuleExcludes = 106639,
+        NamespaceModuleExcludes = 0,
+        MethodExcludes = 99263,
+        GetAccessorExcludes = 41919,
+        SetAccessorExcludes = 74687,
+        TypeParameterExcludes = 2103776,
+        TypeAliasExcludes = 3152352,
+        ImportExcludes = 33554432,
+        ModuleMember = 35653619,
+        ExportHasLocal = 944,
+        HasLocals = 1041936,
+        HasExports = 1952,
+        HasMembers = 6240,
+        IsContainer = 1048560,
+        PropertyOrAccessor = 98308,
+        Export = 29360128,
+    }
+    interface Symbol {
+        flags: SymbolFlags;
+        name: string;
+        id?: number;
+        mergeId?: number;
+        declarations?: Declaration[];
+        parent?: Symbol;
+        members?: SymbolTable;
+        exports?: SymbolTable;
+        exportSymbol?: Symbol;
+        valueDeclaration?: Declaration;
+        constEnumOnlyModule?: boolean;
+    }
+    interface SymbolLinks {
+        target?: Symbol;
+        type?: Type;
+        declaredType?: Type;
+        mapper?: TypeMapper;
+        referenced?: boolean;
+        exportAssignSymbol?: Symbol;
+        unionType?: UnionType;
+    }
+    interface TransientSymbol extends Symbol, SymbolLinks {
+    }
+    interface SymbolTable {
+        [index: string]: Symbol;
+    }
+    const enum NodeCheckFlags {
+        TypeChecked = 1,
+        LexicalThis = 2,
+        CaptureThis = 4,
+        EmitExtends = 8,
+        SuperInstance = 16,
+        SuperStatic = 32,
+        ContextChecked = 64,
+        EnumValuesComputed = 128,
+    }
+    interface NodeLinks {
+        resolvedType?: Type;
+        resolvedSignature?: Signature;
+        resolvedSymbol?: Symbol;
+        flags?: NodeCheckFlags;
+        enumMemberValue?: number;
+        isIllegalTypeReferenceInConstraint?: boolean;
+        isVisible?: boolean;
+        localModuleName?: string;
+        assignmentChecks?: Map<boolean>;
+    }
+    const enum TypeFlags {
+        Any = 1,
+        String = 2,
+        Number = 4,
+        Boolean = 8,
+        Void = 16,
+        Undefined = 32,
+        Null = 64,
+        Enum = 128,
+        StringLiteral = 256,
+        TypeParameter = 512,
+        Class = 1024,
+        Interface = 2048,
+        Reference = 4096,
+        Tuple = 8192,
+        Union = 16384,
+        Anonymous = 32768,
+        FromSignature = 65536,
+        Intrinsic = 127,
+        StringLike = 258,
+        NumberLike = 132,
+        ObjectType = 48128,
+    }
+    interface Type {
+        flags: TypeFlags;
+        id: number;
+        symbol?: Symbol;
+    }
+    interface IntrinsicType extends Type {
+        intrinsicName: string;
+    }
+    interface StringLiteralType extends Type {
+        text: string;
+    }
+    interface ObjectType extends Type {
+    }
+    interface InterfaceType extends ObjectType {
+        typeParameters: TypeParameter[];
+        baseTypes: ObjectType[];
+        declaredProperties: Symbol[];
+        declaredCallSignatures: Signature[];
+        declaredConstructSignatures: Signature[];
+        declaredStringIndexType: Type;
+        declaredNumberIndexType: Type;
+    }
+    interface TypeReference extends ObjectType {
+        target: GenericType;
+        typeArguments: Type[];
+    }
+    interface GenericType extends InterfaceType, TypeReference {
+        instantiations: Map<TypeReference>;
+        openReferenceTargets: GenericType[];
+        openReferenceChecks: Map<boolean>;
+    }
+    interface TupleType extends ObjectType {
+        elementTypes: Type[];
+        baseArrayType: TypeReference;
+    }
+    interface UnionType extends Type {
+        types: Type[];
+        resolvedProperties: SymbolTable;
+    }
+    interface ResolvedType extends ObjectType, UnionType {
+        members: SymbolTable;
+        properties: Symbol[];
+        callSignatures: Signature[];
+        constructSignatures: Signature[];
+        stringIndexType: Type;
+        numberIndexType: Type;
+    }
+    interface TypeParameter extends Type {
+        constraint: Type;
+        target?: TypeParameter;
+        mapper?: TypeMapper;
+    }
+    const enum SignatureKind {
+        Call = 0,
+        Construct = 1,
+    }
+    interface Signature {
+        declaration: SignatureDeclaration;
+        typeParameters: TypeParameter[];
+        parameters: Symbol[];
+        resolvedReturnType: Type;
+        minArgumentCount: number;
+        hasRestParameter: boolean;
+        hasStringLiterals: boolean;
+        target?: Signature;
+        mapper?: TypeMapper;
+        unionSignatures?: Signature[];
+        erasedSignatureCache?: Signature;
+        isolatedSignatureType?: ObjectType;
+    }
+    const enum IndexKind {
+        String = 0,
+        Number = 1,
+    }
+    interface TypeMapper {
+        (t: Type): Type;
+    }
+    interface TypeInferences {
+        primary: Type[];
+        secondary: Type[];
+    }
+    interface InferenceContext {
+        typeParameters: TypeParameter[];
+        inferUnionTypes: boolean;
+        inferences: TypeInferences[];
+        inferredTypes: Type[];
+        failedTypeParameterIndex?: number;
+    }
+    interface DiagnosticMessage {
+        key: string;
+        category: DiagnosticCategory;
+        code: number;
+        isEarly?: boolean;
+    }
+    interface DiagnosticMessageChain {
+        messageText: string;
+        category: DiagnosticCategory;
+        code: number;
+        next?: DiagnosticMessageChain;
+    }
+    interface Diagnostic {
+        file: SourceFile;
+        start: number;
+        length: number;
+        messageText: string;
+        category: DiagnosticCategory;
+        code: number;
+        /**
+          * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit
+          */
+        isEarly?: boolean;
+    }
+    enum DiagnosticCategory {
+        Warning = 0,
+        Error = 1,
+        Message = 2,
+    }
+    interface CompilerOptions {
+        allowNonTsExtensions?: boolean;
+        charset?: string;
+        codepage?: number;
+        declaration?: boolean;
+        diagnostics?: boolean;
+        emitBOM?: boolean;
+        help?: boolean;
+        locale?: string;
+        mapRoot?: string;
+        module?: ModuleKind;
+        noEmitOnError?: boolean;
+        noErrorTruncation?: boolean;
+        noImplicitAny?: boolean;
+        noLib?: boolean;
+        noLibCheck?: boolean;
+        noResolve?: boolean;
+        out?: string;
+        outDir?: string;
+        preserveConstEnums?: boolean;
+        removeComments?: boolean;
+        sourceMap?: boolean;
+        sourceRoot?: string;
+        suppressImplicitAnyIndexErrors?: boolean;
+        target?: ScriptTarget;
+        version?: boolean;
+        watch?: boolean;
+        [option: string]: string | number | boolean;
+    }
+    const enum ModuleKind {
+        None = 0,
+        CommonJS = 1,
+        AMD = 2,
+    }
+    interface LineAndCharacter {
+        line: number;
+        character: number;
+    }
+    const enum ScriptTarget {
+        ES3 = 0,
+        ES5 = 1,
+        ES6 = 2,
+        Latest = 2,
+    }
+    interface ParsedCommandLine {
+        options: CompilerOptions;
+        filenames: string[];
+        errors: Diagnostic[];
+    }
+    interface CommandLineOption {
+        name: string;
+        type: string | Map<number>;
+        shortName?: string;
+        description?: DiagnosticMessage;
+        paramType?: DiagnosticMessage;
+        error?: DiagnosticMessage;
+    }
+    const enum CharacterCodes {
+        nullCharacter = 0,
+        maxAsciiCharacter = 127,
+        lineFeed = 10,
+        carriageReturn = 13,
+        lineSeparator = 8232,
+        paragraphSeparator = 8233,
+        nextLine = 133,
+        space = 32,
+        nonBreakingSpace = 160,
+        enQuad = 8192,
+        emQuad = 8193,
+        enSpace = 8194,
+        emSpace = 8195,
+        threePerEmSpace = 8196,
+        fourPerEmSpace = 8197,
+        sixPerEmSpace = 8198,
+        figureSpace = 8199,
+        punctuationSpace = 8200,
+        thinSpace = 8201,
+        hairSpace = 8202,
+        zeroWidthSpace = 8203,
+        narrowNoBreakSpace = 8239,
+        ideographicSpace = 12288,
+        mathematicalSpace = 8287,
+        ogham = 5760,
+        _ = 95,
+        $ = 36,
+        _0 = 48,
+        _1 = 49,
+        _2 = 50,
+        _3 = 51,
+        _4 = 52,
+        _5 = 53,
+        _6 = 54,
+        _7 = 55,
+        _8 = 56,
+        _9 = 57,
+        a = 97,
+        b = 98,
+        c = 99,
+        d = 100,
+        e = 101,
+        f = 102,
+        g = 103,
+        h = 104,
+        i = 105,
+        j = 106,
+        k = 107,
+        l = 108,
+        m = 109,
+        n = 110,
+        o = 111,
+        p = 112,
+        q = 113,
+        r = 114,
+        s = 115,
+        t = 116,
+        u = 117,
+        v = 118,
+        w = 119,
+        x = 120,
+        y = 121,
+        z = 122,
+        A = 65,
+        B = 66,
+        C = 67,
+        D = 68,
+        E = 69,
+        F = 70,
+        G = 71,
+        H = 72,
+        I = 73,
+        J = 74,
+        K = 75,
+        L = 76,
+        M = 77,
+        N = 78,
+        O = 79,
+        P = 80,
+        Q = 81,
+        R = 82,
+        S = 83,
+        T = 84,
+        U = 85,
+        V = 86,
+        W = 87,
+        X = 88,
+        Y = 89,
+        Z = 90,
+        ampersand = 38,
+        asterisk = 42,
+        at = 64,
+        backslash = 92,
+        backtick = 96,
+        bar = 124,
+        caret = 94,
+        closeBrace = 125,
+        closeBracket = 93,
+        closeParen = 41,
+        colon = 58,
+        comma = 44,
+        dot = 46,
+        doubleQuote = 34,
+        equals = 61,
+        exclamation = 33,
+        greaterThan = 62,
+        lessThan = 60,
+        minus = 45,
+        openBrace = 123,
+        openBracket = 91,
+        openParen = 40,
+        percent = 37,
+        plus = 43,
+        question = 63,
+        semicolon = 59,
+        singleQuote = 39,
+        slash = 47,
+        tilde = 126,
+        backspace = 8,
+        formFeed = 12,
+        byteOrderMark = 65279,
+        tab = 9,
+        verticalTab = 11,
+    }
+    interface CancellationToken {
+        isCancellationRequested(): boolean;
+    }
+    interface CompilerHost {
+        getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
+        getDefaultLibFilename(options: CompilerOptions): string;
+        getCancellationToken?(): CancellationToken;
+        writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void;
+        getCurrentDirectory(): string;
+        getCanonicalFileName(fileName: string): string;
+        useCaseSensitiveFileNames(): boolean;
+        getNewLine(): string;
+    }
+}
+declare module ts {
+    interface ErrorCallback {
+        (message: DiagnosticMessage): void;
+    }
+    interface CommentCallback {
+        (pos: number, end: number): void;
+    }
+    interface Scanner {
+        getStartPos(): number;
+        getToken(): SyntaxKind;
+        getTextPos(): number;
+        getTokenPos(): number;
+        getTokenText(): string;
+        getTokenValue(): string;
+        hasPrecedingLineBreak(): boolean;
+        isIdentifier(): boolean;
+        isReservedWord(): boolean;
+        isUnterminated(): boolean;
+        reScanGreaterToken(): SyntaxKind;
+        reScanSlashToken(): SyntaxKind;
+        reScanTemplateToken(): SyntaxKind;
+        scan(): SyntaxKind;
+        setText(text: string): void;
+        setTextPos(textPos: number): void;
+        lookAhead<T>(callback: () => T): T;
+        tryScan<T>(callback: () => T): T;
+    }
+    function tokenToString(t: SyntaxKind): string;
+    function computeLineStarts(text: string): number[];
+    function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number;
+    function getLineAndCharacterOfPosition(lineStarts: number[], position: number): {
+        line: number;
+        character: number;
+    };
+    function positionToLineAndCharacter(text: string, pos: number): {
+        line: number;
+        character: number;
+    };
+    function isWhiteSpace(ch: number): boolean;
+    function isLineBreak(ch: number): boolean;
+    function isOctalDigit(ch: number): boolean;
+    function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number;
+    function getLeadingCommentRanges(text: string, pos: number): CommentRange[];
+    function getTrailingCommentRanges(text: string, pos: number): CommentRange[];
+    function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;
+    function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;
+    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner;
+}
+declare module ts {
+    function getNodeConstructor(kind: SyntaxKind): new () => Node;
+    function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T;
+    function createCompilerHost(options: CompilerOptions): CompilerHost;
+    function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile;
+    function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program;
+}
+declare module ts {
+    function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker;
+}
+declare module ts {
+    var servicesVersion: string;
+    interface Node {
+        getSourceFile(): SourceFile;
+        getChildCount(sourceFile?: SourceFile): number;
+        getChildAt(index: number, sourceFile?: SourceFile): Node;
+        getChildren(sourceFile?: SourceFile): Node[];
+        getStart(sourceFile?: SourceFile): number;
+        getFullStart(): number;
+        getEnd(): number;
+        getWidth(sourceFile?: SourceFile): number;
+        getFullWidth(): number;
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;
+        getFullText(sourceFile?: SourceFile): string;
+        getText(sourceFile?: SourceFile): string;
+        getFirstToken(sourceFile?: SourceFile): Node;
+        getLastToken(sourceFile?: SourceFile): Node;
+    }
+    interface Symbol {
+        getFlags(): SymbolFlags;
+        getName(): string;
+        getDeclarations(): Declaration[];
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+    interface Type {
+        getFlags(): TypeFlags;
+        getSymbol(): Symbol;
+        getProperties(): Symbol[];
+        getProperty(propertyName: string): Symbol;
+        getApparentProperties(): Symbol[];
+        getCallSignatures(): Signature[];
+        getConstructSignatures(): Signature[];
+        getStringIndexType(): Type;
+        getNumberIndexType(): Type;
+    }
+    interface Signature {
+        getDeclaration(): SignatureDeclaration;
+        getTypeParameters(): Type[];
+        getParameters(): Symbol[];
+        getReturnType(): Type;
+        getDocumentationComment(): SymbolDisplayPart[];
+    }
+    interface SourceFile {
+        getScriptSnapshot(): IScriptSnapshot;
+        getNamedDeclarations(): Declaration[];
+        update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;
+    }
+    /**
+     * Represents an immutable snapshot of a script at a specified time.Once acquired, the
+     * snapshot is observably immutable. i.e. the same calls with the same parameters will return
+     * the same values.
+     */
+    interface IScriptSnapshot {
+        /** Gets a portion of the script snapshot specified by [start, end). */
+        getText(start: number, end: number): string;
+        /** Gets the length of this script snapshot. */
+        getLength(): number;
+        /**
+         * This call returns the array containing the start position of every line.
+         * i.e."[0, 10, 55]".  TODO: consider making this optional.  The language service could
+         * always determine this (albeit in a more expensive manner).
+         */
+        getLineStartPositions(): number[];
+        /**
+         * Gets the TextChangeRange that describe how the text changed between this text and
+         * an older version.  This information is used by the incremental parser to determine
+         * what sections of the script need to be re-parsed.  'undefined' can be returned if the
+         * change range cannot be determined.  However, in that case, incremental parsing will
+         * not happen and the entire document will be re - parsed.
+         */
+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;
+    }
+    module ScriptSnapshot {
+        function fromString(text: string): IScriptSnapshot;
+    }
+    interface PreProcessedFileInfo {
+        referencedFiles: FileReference[];
+        importedFiles: FileReference[];
+        isLibFile: boolean;
+    }
+    interface Logger {
+        log(s: string): void;
+    }
+    interface LanguageServiceHost extends Logger {
+        getCompilationSettings(): CompilerOptions;
+        getScriptFileNames(): string[];
+        getScriptVersion(fileName: string): string;
+        getScriptIsOpen(fileName: string): boolean;
+        getScriptSnapshot(fileName: string): IScriptSnapshot;
+        getLocalizedDiagnosticMessages?(): any;
+        getCancellationToken?(): CancellationToken;
+        getCurrentDirectory(): string;
+        getDefaultLibFilename(options: CompilerOptions): string;
+    }
+    interface LanguageService {
+        cleanupSemanticCache(): void;
+        getSyntacticDiagnostics(fileName: string): Diagnostic[];
+        getSemanticDiagnostics(fileName: string): Diagnostic[];
+        getCompilerOptionsDiagnostics(): Diagnostic[];
+        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
+        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
+        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;
+        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;
+        getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;
+        getRenameInfo(fileName: string, position: number): RenameInfo;
+        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
+        getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
+        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
+        getNavigateToItems(searchValue: string): NavigateToItem[];
+        getNavigationBarItems(fileName: string): NavigationBarItem[];
+        getOutliningSpans(fileName: string): OutliningSpan[];
+        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
+        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number;
+        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[];
+        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[];
+        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[];
+        getEmitOutput(fileName: string): EmitOutput;
+        getSourceFile(filename: string): SourceFile;
+        dispose(): void;
+    }
+    class TextSpan {
+        private _start;
+        private _length;
+        /**
+            * Creates a TextSpan instance beginning with the position Start and having the Length
+            * specified with length.
+            */
+        constructor(start: number, length: number);
+        toJSON(key: any): any;
+        start(): number;
+        length(): number;
+        end(): number;
+        isEmpty(): boolean;
+        /**
+            * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less
+            * than End, otherwise false.
+            * @param position The position to check.
+            */
+        containsPosition(position: number): boolean;
+        /**
+            * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.
+            * @param span The span to check.
+            */
+        containsTextSpan(span: TextSpan): boolean;
+        /**
+            * Determines whether the given span overlaps this span. Two spans are considered to overlap
+            * if they have positions in common and neither is empty. Empty spans do not overlap with any
+            * other span. Returns true if the spans overlap, false otherwise.
+            * @param span The span to check.
+            */
+        overlapsWith(span: TextSpan): boolean;
+        /**
+            * Returns the overlap with the given span, or undefined if there is no overlap.
+            * @param span The span to check.
+            */
+        overlap(span: TextSpan): TextSpan;
+        /**
+            * Determines whether span intersects this span. Two spans are considered to
+            * intersect if they have positions in common or the end of one span
+            * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.
+            * @param The span to check.
+            */
+        intersectsWithTextSpan(span: TextSpan): boolean;
+        intersectsWith(start: number, length: number): boolean;
+        /**
+            * Determines whether the given position intersects this span.
+            * A position is considered to intersect if it is between the start and
+            * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.
+            * @param position The position to check.
+            */
+        intersectsWithPosition(position: number): boolean;
+        /**
+            * Returns the intersection with the given span, or undefined if there is no intersection.
+            * @param span The span to check.
+            */
+        intersection(span: TextSpan): TextSpan;
+        /**
+            * Creates a new TextSpan from the given start and end positions
+            * as opposed to a position and length.
+            */
+        static fromBounds(start: number, end: number): TextSpan;
+    }
+    class TextChangeRange {
+        static unchanged: TextChangeRange;
+        private _span;
+        private _newLength;
+        /**
+            * Initializes a new instance of TextChangeRange.
+            */
+        constructor(span: TextSpan, newLength: number);
+        /**
+            * The span of text before the edit which is being changed
+            */
+        span(): TextSpan;
+        /**
+            * Width of the span after the edit.  A 0 here would represent a delete
+            */
+        newLength(): number;
+        newSpan(): TextSpan;
+        isUnchanged(): boolean;
+        /**
+            * Called to merge all the changes that occurred across several versions of a script snapshot
+            * into a single change.  i.e. if a user keeps making successive edits to a script we will
+            * have a text change from V1 to V2, V2 to V3, ..., Vn.
+            *
+            * This function will then merge those changes into a single change range valid between V1 and
+            * Vn.
+            */
+        static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
+    }
+    interface ClassifiedSpan {
+        textSpan: TextSpan;
+        classificationType: string;
+    }
+    interface NavigationBarItem {
+        text: string;
+        kind: string;
+        kindModifiers: string;
+        spans: TextSpan[];
+        childItems: NavigationBarItem[];
+        indent: number;
+        bolded: boolean;
+        grayed: boolean;
+    }
+    interface TodoCommentDescriptor {
+        text: string;
+        priority: number;
+    }
+    interface TodoComment {
+        descriptor: TodoCommentDescriptor;
+        message: string;
+        position: number;
+    }
+    class TextChange {
+        span: TextSpan;
+        newText: string;
+    }
+    interface RenameLocation {
+        textSpan: TextSpan;
+        fileName: string;
+    }
+    interface ReferenceEntry {
+        textSpan: TextSpan;
+        fileName: string;
+        isWriteAccess: boolean;
+    }
+    interface NavigateToItem {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+        matchKind: string;
+        fileName: string;
+        textSpan: TextSpan;
+        containerName: string;
+        containerKind: string;
+    }
+    interface EditorOptions {
+        IndentSize: number;
+        TabSize: number;
+        NewLineCharacter: string;
+        ConvertTabsToSpaces: boolean;
+    }
+    interface FormatCodeOptions extends EditorOptions {
+        InsertSpaceAfterCommaDelimiter: boolean;
+        InsertSpaceAfterSemicolonInForStatements: boolean;
+        InsertSpaceBeforeAndAfterBinaryOperators: boolean;
+        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
+        PlaceOpenBraceOnNewLineForFunctions: boolean;
+        PlaceOpenBraceOnNewLineForControlBlocks: boolean;
+    }
+    interface DefinitionInfo {
+        fileName: string;
+        textSpan: TextSpan;
+        kind: string;
+        name: string;
+        containerKind: string;
+        containerName: string;
+    }
+    enum SymbolDisplayPartKind {
+        aliasName = 0,
+        className = 1,
+        enumName = 2,
+        fieldName = 3,
+        interfaceName = 4,
+        keyword = 5,
+        lineBreak = 6,
+        numericLiteral = 7,
+        stringLiteral = 8,
+        localName = 9,
+        methodName = 10,
+        moduleName = 11,
+        operator = 12,
+        parameterName = 13,
+        propertyName = 14,
+        punctuation = 15,
+        space = 16,
+        text = 17,
+        typeParameterName = 18,
+        enumMemberName = 19,
+        functionName = 20,
+        regularExpressionLiteral = 21,
+    }
+    interface SymbolDisplayPart {
+        text: string;
+        kind: string;
+    }
+    interface QuickInfo {
+        kind: string;
+        kindModifiers: string;
+        textSpan: TextSpan;
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+    interface RenameInfo {
+        canRename: boolean;
+        localizedErrorMessage: string;
+        displayName: string;
+        fullDisplayName: string;
+        kind: string;
+        kindModifiers: string;
+        triggerSpan: TextSpan;
+    }
+    interface SignatureHelpParameter {
+        name: string;
+        documentation: SymbolDisplayPart[];
+        displayParts: SymbolDisplayPart[];
+        isOptional: boolean;
+    }
+    /**
+     * Represents a single signature to show in signature help.
+     * The id is used for subsequent calls into the language service to ask questions about the
+     * signature help item in the context of any documents that have been updated.  i.e. after
+     * an edit has happened, while signature help is still active, the host can ask important
+     * questions like 'what parameter is the user currently contained within?'.
+     */
+    interface SignatureHelpItem {
+        isVariadic: boolean;
+        prefixDisplayParts: SymbolDisplayPart[];
+        suffixDisplayParts: SymbolDisplayPart[];
+        separatorDisplayParts: SymbolDisplayPart[];
+        parameters: SignatureHelpParameter[];
+        documentation: SymbolDisplayPart[];
+    }
+    /**
+     * Represents a set of signature help items, and the preferred item that should be selected.
+     */
+    interface SignatureHelpItems {
+        items: SignatureHelpItem[];
+        applicableSpan: TextSpan;
+        selectedItemIndex: number;
+        argumentIndex: number;
+        argumentCount: number;
+    }
+    interface CompletionInfo {
+        isMemberCompletion: boolean;
+        entries: CompletionEntry[];
+    }
+    interface CompletionEntry {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+    }
+    interface CompletionEntryDetails {
+        name: string;
+        kind: string;
+        kindModifiers: string;
+        displayParts: SymbolDisplayPart[];
+        documentation: SymbolDisplayPart[];
+    }
+    interface OutliningSpan {
+        /** The span of the document to actually collapse. */
+        textSpan: TextSpan;
+        /** The span of the document to display when the user hovers over the collapsed span. */
+        hintSpan: TextSpan;
+        /** The text to display in the editor for the collapsed region. */
+        bannerText: string;
+        /**
+          * Whether or not this region should be automatically collapsed when
+          * the 'Collapse to Definitions' command is invoked.
+          */
+        autoCollapse: boolean;
+    }
+    interface EmitOutput {
+        outputFiles: OutputFile[];
+        emitOutputStatus: EmitReturnStatus;
+    }
+    const enum OutputFileType {
+        JavaScript = 0,
+        SourceMap = 1,
+        Declaration = 2,
+    }
+    interface OutputFile {
+        name: string;
+        writeByteOrderMark: boolean;
+        text: string;
+    }
+    const enum EndOfLineState {
+        Start = 0,
+        InMultiLineCommentTrivia = 1,
+        InSingleQuoteStringLiteral = 2,
+        InDoubleQuoteStringLiteral = 3,
+    }
+    enum TokenClass {
+        Punctuation = 0,
+        Keyword = 1,
+        Operator = 2,
+        Comment = 3,
+        Whitespace = 4,
+        Identifier = 5,
+        NumberLiteral = 6,
+        StringLiteral = 7,
+        RegExpLiteral = 8,
+    }
+    interface ClassificationResult {
+        finalLexState: EndOfLineState;
+        entries: ClassificationInfo[];
+    }
+    interface ClassificationInfo {
+        length: number;
+        classification: TokenClass;
+    }
+    interface Classifier {
+        getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult;
+    }
+    interface DocumentRegistry {
+        acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile;
+        updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;
+        releaseDocument(filename: string, compilationSettings: CompilerOptions): void;
+    }
+    class ScriptElementKind {
+        static unknown: string;
+        static keyword: string;
+        static scriptElement: string;
+        static moduleElement: string;
+        static classElement: string;
+        static interfaceElement: string;
+        static typeElement: string;
+        static enumElement: string;
+        static variableElement: string;
+        static localVariableElement: string;
+        static functionElement: string;
+        static localFunctionElement: string;
+        static memberFunctionElement: string;
+        static memberGetAccessorElement: string;
+        static memberSetAccessorElement: string;
+        static memberVariableElement: string;
+        static constructorImplementationElement: string;
+        static callSignatureElement: string;
+        static indexSignatureElement: string;
+        static constructSignatureElement: string;
+        static parameterElement: string;
+        static typeParameterElement: string;
+        static primitiveType: string;
+        static label: string;
+        static alias: string;
+        static constElement: string;
+        static letElement: string;
+    }
+    class ScriptElementKindModifier {
+        static none: string;
+        static publicMemberModifier: string;
+        static privateMemberModifier: string;
+        static protectedMemberModifier: string;
+        static exportedModifier: string;
+        static ambientModifier: string;
+        static staticModifier: string;
+    }
+    class ClassificationTypeNames {
+        static comment: string;
+        static identifier: string;
+        static keyword: string;
+        static numericLiteral: string;
+        static operator: string;
+        static stringLiteral: string;
+        static whiteSpace: string;
+        static text: string;
+        static punctuation: string;
+        static className: string;
+        static enumName: string;
+        static interfaceName: string;
+        static moduleName: string;
+        static typeParameterName: string;
+        static typeAlias: string;
+    }
+    interface DisplayPartsSymbolWriter extends SymbolWriter {
+        displayParts(): SymbolDisplayPart[];
+    }
+    function displayPartsToString(displayParts: SymbolDisplayPart[]): string;
+    function getDefaultCompilerOptions(): CompilerOptions;
+    class OperationCanceledException {
+    }
+    class CancellationTokenObject {
+        private cancellationToken;
+        static None: CancellationTokenObject;
+        constructor(cancellationToken: CancellationToken);
+        isCancellationRequested(): boolean;
+        throwIfCancellationRequested(): void;
+    }
+    function createDocumentRegistry(): DocumentRegistry;
+    function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;
+    function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService;
+    function createClassifier(host: Logger): Classifier;
+}
+
+
+//// [APISample_standalone_compile.js]
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", 2 /* Latest */, "0.0");
+var program = ts.createProgram(["file1.ts"], {}, undefined);
diff --git a/tests/baselines/reference/APISample_standalone_compile.types b/tests/baselines/reference/APISample_standalone_compile.types
new file mode 100644
index 00000000000..465a89b8f97
--- /dev/null
+++ b/tests/baselines/reference/APISample_standalone_compile.types
@@ -0,0 +1,5756 @@
+=== tests/cases/compiler/APISample_standalone_compile.ts ===
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+>sourceFile : ts.SourceFile
+>ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0") : ts.SourceFile
+>ts.createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile
+>ts : typeof ts
+>createSourceFile : (filename: string, sourceText: string, languageVersion: ts.ScriptTarget, version: string, isOpen?: boolean) => ts.SourceFile
+>ts.ScriptTarget.Latest : ts.ScriptTarget
+>ts.ScriptTarget : typeof ts.ScriptTarget
+>ts : typeof ts
+>ScriptTarget : typeof ts.ScriptTarget
+>Latest : ts.ScriptTarget
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
+>program : ts.Program
+>ts.createProgram(["file1.ts"], {}, undefined) : ts.Program
+>ts.createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program
+>ts : typeof ts
+>createProgram : (rootNames: string[], options: ts.CompilerOptions, host: ts.CompilerHost) => ts.Program
+>["file1.ts"] : string[]
+>{} : { [x: string]: undefined; }
+>undefined : undefined
+
+=== typescriptServices.d.ts ===
+/*! *****************************************************************************

+Copyright (c) Microsoft Corporation. All rights reserved. 

+Licensed under the Apache License, Version 2.0 (the "License"); you may not use

+this file except in compliance with the License. You may obtain a copy of the

+License at http://www.apache.org/licenses/LICENSE-2.0  

+ 

+THIS CODE IS PROVIDED ON AN *AS IS* BASIS, WITHOUT WARRANTIES OR CONDITIONS OF ANY

+KIND, EITHER EXPRESS OR IMPLIED, INCLUDING WITHOUT LIMITATION ANY IMPLIED

+WARRANTIES OR CONDITIONS OF TITLE, FITNESS FOR A PARTICULAR PURPOSE, 

+MERCHANTABLITY OR NON-INFRINGEMENT. 

+ 

+See the Apache Version 2.0 License for specific language governing permissions

+and limitations under the License.

+***************************************************************************** */

+

+declare module ts {

+>ts : typeof ts
+
+    interface Map<T> {

+>Map : Map<T>
+>T : T
+
+        [index: string]: T;

+>index : string
+>T : T
+    }

+    interface TextRange {

+>TextRange : TextRange
+
+        pos: number;

+>pos : number
+
+        end: number;

+>end : number
+    }

+    const enum SyntaxKind {

+>SyntaxKind : SyntaxKind
+
+        Unknown = 0,

+>Unknown : SyntaxKind
+
+        EndOfFileToken = 1,

+>EndOfFileToken : SyntaxKind
+
+        SingleLineCommentTrivia = 2,

+>SingleLineCommentTrivia : SyntaxKind
+
+        MultiLineCommentTrivia = 3,

+>MultiLineCommentTrivia : SyntaxKind
+
+        NewLineTrivia = 4,

+>NewLineTrivia : SyntaxKind
+
+        WhitespaceTrivia = 5,

+>WhitespaceTrivia : SyntaxKind
+
+        NumericLiteral = 6,

+>NumericLiteral : SyntaxKind
+
+        StringLiteral = 7,

+>StringLiteral : SyntaxKind
+
+        RegularExpressionLiteral = 8,

+>RegularExpressionLiteral : SyntaxKind
+
+        NoSubstitutionTemplateLiteral = 9,

+>NoSubstitutionTemplateLiteral : SyntaxKind
+
+        TemplateHead = 10,

+>TemplateHead : SyntaxKind
+
+        TemplateMiddle = 11,

+>TemplateMiddle : SyntaxKind
+
+        TemplateTail = 12,

+>TemplateTail : SyntaxKind
+
+        OpenBraceToken = 13,

+>OpenBraceToken : SyntaxKind
+
+        CloseBraceToken = 14,

+>CloseBraceToken : SyntaxKind
+
+        OpenParenToken = 15,

+>OpenParenToken : SyntaxKind
+
+        CloseParenToken = 16,

+>CloseParenToken : SyntaxKind
+
+        OpenBracketToken = 17,

+>OpenBracketToken : SyntaxKind
+
+        CloseBracketToken = 18,

+>CloseBracketToken : SyntaxKind
+
+        DotToken = 19,

+>DotToken : SyntaxKind
+
+        DotDotDotToken = 20,

+>DotDotDotToken : SyntaxKind
+
+        SemicolonToken = 21,

+>SemicolonToken : SyntaxKind
+
+        CommaToken = 22,

+>CommaToken : SyntaxKind
+
+        LessThanToken = 23,

+>LessThanToken : SyntaxKind
+
+        GreaterThanToken = 24,

+>GreaterThanToken : SyntaxKind
+
+        LessThanEqualsToken = 25,

+>LessThanEqualsToken : SyntaxKind
+
+        GreaterThanEqualsToken = 26,

+>GreaterThanEqualsToken : SyntaxKind
+
+        EqualsEqualsToken = 27,

+>EqualsEqualsToken : SyntaxKind
+
+        ExclamationEqualsToken = 28,

+>ExclamationEqualsToken : SyntaxKind
+
+        EqualsEqualsEqualsToken = 29,

+>EqualsEqualsEqualsToken : SyntaxKind
+
+        ExclamationEqualsEqualsToken = 30,

+>ExclamationEqualsEqualsToken : SyntaxKind
+
+        EqualsGreaterThanToken = 31,

+>EqualsGreaterThanToken : SyntaxKind
+
+        PlusToken = 32,

+>PlusToken : SyntaxKind
+
+        MinusToken = 33,

+>MinusToken : SyntaxKind
+
+        AsteriskToken = 34,

+>AsteriskToken : SyntaxKind
+
+        SlashToken = 35,

+>SlashToken : SyntaxKind
+
+        PercentToken = 36,

+>PercentToken : SyntaxKind
+
+        PlusPlusToken = 37,

+>PlusPlusToken : SyntaxKind
+
+        MinusMinusToken = 38,

+>MinusMinusToken : SyntaxKind
+
+        LessThanLessThanToken = 39,

+>LessThanLessThanToken : SyntaxKind
+
+        GreaterThanGreaterThanToken = 40,

+>GreaterThanGreaterThanToken : SyntaxKind
+
+        GreaterThanGreaterThanGreaterThanToken = 41,

+>GreaterThanGreaterThanGreaterThanToken : SyntaxKind
+
+        AmpersandToken = 42,

+>AmpersandToken : SyntaxKind
+
+        BarToken = 43,

+>BarToken : SyntaxKind
+
+        CaretToken = 44,

+>CaretToken : SyntaxKind
+
+        ExclamationToken = 45,

+>ExclamationToken : SyntaxKind
+
+        TildeToken = 46,

+>TildeToken : SyntaxKind
+
+        AmpersandAmpersandToken = 47,

+>AmpersandAmpersandToken : SyntaxKind
+
+        BarBarToken = 48,

+>BarBarToken : SyntaxKind
+
+        QuestionToken = 49,

+>QuestionToken : SyntaxKind
+
+        ColonToken = 50,

+>ColonToken : SyntaxKind
+
+        EqualsToken = 51,

+>EqualsToken : SyntaxKind
+
+        PlusEqualsToken = 52,

+>PlusEqualsToken : SyntaxKind
+
+        MinusEqualsToken = 53,

+>MinusEqualsToken : SyntaxKind
+
+        AsteriskEqualsToken = 54,

+>AsteriskEqualsToken : SyntaxKind
+
+        SlashEqualsToken = 55,

+>SlashEqualsToken : SyntaxKind
+
+        PercentEqualsToken = 56,

+>PercentEqualsToken : SyntaxKind
+
+        LessThanLessThanEqualsToken = 57,

+>LessThanLessThanEqualsToken : SyntaxKind
+
+        GreaterThanGreaterThanEqualsToken = 58,

+>GreaterThanGreaterThanEqualsToken : SyntaxKind
+
+        GreaterThanGreaterThanGreaterThanEqualsToken = 59,

+>GreaterThanGreaterThanGreaterThanEqualsToken : SyntaxKind
+
+        AmpersandEqualsToken = 60,

+>AmpersandEqualsToken : SyntaxKind
+
+        BarEqualsToken = 61,

+>BarEqualsToken : SyntaxKind
+
+        CaretEqualsToken = 62,

+>CaretEqualsToken : SyntaxKind
+
+        Identifier = 63,

+>Identifier : SyntaxKind
+
+        BreakKeyword = 64,

+>BreakKeyword : SyntaxKind
+
+        CaseKeyword = 65,

+>CaseKeyword : SyntaxKind
+
+        CatchKeyword = 66,

+>CatchKeyword : SyntaxKind
+
+        ClassKeyword = 67,

+>ClassKeyword : SyntaxKind
+
+        ConstKeyword = 68,

+>ConstKeyword : SyntaxKind
+
+        ContinueKeyword = 69,

+>ContinueKeyword : SyntaxKind
+
+        DebuggerKeyword = 70,

+>DebuggerKeyword : SyntaxKind
+
+        DefaultKeyword = 71,

+>DefaultKeyword : SyntaxKind
+
+        DeleteKeyword = 72,

+>DeleteKeyword : SyntaxKind
+
+        DoKeyword = 73,

+>DoKeyword : SyntaxKind
+
+        ElseKeyword = 74,

+>ElseKeyword : SyntaxKind
+
+        EnumKeyword = 75,

+>EnumKeyword : SyntaxKind
+
+        ExportKeyword = 76,

+>ExportKeyword : SyntaxKind
+
+        ExtendsKeyword = 77,

+>ExtendsKeyword : SyntaxKind
+
+        FalseKeyword = 78,

+>FalseKeyword : SyntaxKind
+
+        FinallyKeyword = 79,

+>FinallyKeyword : SyntaxKind
+
+        ForKeyword = 80,

+>ForKeyword : SyntaxKind
+
+        FunctionKeyword = 81,

+>FunctionKeyword : SyntaxKind
+
+        IfKeyword = 82,

+>IfKeyword : SyntaxKind
+
+        ImportKeyword = 83,

+>ImportKeyword : SyntaxKind
+
+        InKeyword = 84,

+>InKeyword : SyntaxKind
+
+        InstanceOfKeyword = 85,

+>InstanceOfKeyword : SyntaxKind
+
+        NewKeyword = 86,

+>NewKeyword : SyntaxKind
+
+        NullKeyword = 87,

+>NullKeyword : SyntaxKind
+
+        ReturnKeyword = 88,

+>ReturnKeyword : SyntaxKind
+
+        SuperKeyword = 89,

+>SuperKeyword : SyntaxKind
+
+        SwitchKeyword = 90,

+>SwitchKeyword : SyntaxKind
+
+        ThisKeyword = 91,

+>ThisKeyword : SyntaxKind
+
+        ThrowKeyword = 92,

+>ThrowKeyword : SyntaxKind
+
+        TrueKeyword = 93,

+>TrueKeyword : SyntaxKind
+
+        TryKeyword = 94,

+>TryKeyword : SyntaxKind
+
+        TypeOfKeyword = 95,

+>TypeOfKeyword : SyntaxKind
+
+        VarKeyword = 96,

+>VarKeyword : SyntaxKind
+
+        VoidKeyword = 97,

+>VoidKeyword : SyntaxKind
+
+        WhileKeyword = 98,

+>WhileKeyword : SyntaxKind
+
+        WithKeyword = 99,

+>WithKeyword : SyntaxKind
+
+        ImplementsKeyword = 100,

+>ImplementsKeyword : SyntaxKind
+
+        InterfaceKeyword = 101,

+>InterfaceKeyword : SyntaxKind
+
+        LetKeyword = 102,

+>LetKeyword : SyntaxKind
+
+        PackageKeyword = 103,

+>PackageKeyword : SyntaxKind
+
+        PrivateKeyword = 104,

+>PrivateKeyword : SyntaxKind
+
+        ProtectedKeyword = 105,

+>ProtectedKeyword : SyntaxKind
+
+        PublicKeyword = 106,

+>PublicKeyword : SyntaxKind
+
+        StaticKeyword = 107,

+>StaticKeyword : SyntaxKind
+
+        YieldKeyword = 108,

+>YieldKeyword : SyntaxKind
+
+        AnyKeyword = 109,

+>AnyKeyword : SyntaxKind
+
+        BooleanKeyword = 110,

+>BooleanKeyword : SyntaxKind
+
+        ConstructorKeyword = 111,

+>ConstructorKeyword : SyntaxKind
+
+        DeclareKeyword = 112,

+>DeclareKeyword : SyntaxKind
+
+        GetKeyword = 113,

+>GetKeyword : SyntaxKind
+
+        ModuleKeyword = 114,

+>ModuleKeyword : SyntaxKind
+
+        RequireKeyword = 115,

+>RequireKeyword : SyntaxKind
+
+        NumberKeyword = 116,

+>NumberKeyword : SyntaxKind
+
+        SetKeyword = 117,

+>SetKeyword : SyntaxKind
+
+        StringKeyword = 118,

+>StringKeyword : SyntaxKind
+
+        TypeKeyword = 119,

+>TypeKeyword : SyntaxKind
+
+        QualifiedName = 120,

+>QualifiedName : SyntaxKind
+
+        ComputedPropertyName = 121,

+>ComputedPropertyName : SyntaxKind
+
+        TypeParameter = 122,

+>TypeParameter : SyntaxKind
+
+        Parameter = 123,

+>Parameter : SyntaxKind
+
+        Property = 124,

+>Property : SyntaxKind
+
+        Method = 125,

+>Method : SyntaxKind
+
+        Constructor = 126,

+>Constructor : SyntaxKind
+
+        GetAccessor = 127,

+>GetAccessor : SyntaxKind
+
+        SetAccessor = 128,

+>SetAccessor : SyntaxKind
+
+        CallSignature = 129,

+>CallSignature : SyntaxKind
+
+        ConstructSignature = 130,

+>ConstructSignature : SyntaxKind
+
+        IndexSignature = 131,

+>IndexSignature : SyntaxKind
+
+        TypeReference = 132,

+>TypeReference : SyntaxKind
+
+        FunctionType = 133,

+>FunctionType : SyntaxKind
+
+        ConstructorType = 134,

+>ConstructorType : SyntaxKind
+
+        TypeQuery = 135,

+>TypeQuery : SyntaxKind
+
+        TypeLiteral = 136,

+>TypeLiteral : SyntaxKind
+
+        ArrayType = 137,

+>ArrayType : SyntaxKind
+
+        TupleType = 138,

+>TupleType : SyntaxKind
+
+        UnionType = 139,

+>UnionType : SyntaxKind
+
+        ParenthesizedType = 140,

+>ParenthesizedType : SyntaxKind
+
+        ArrayLiteralExpression = 141,

+>ArrayLiteralExpression : SyntaxKind
+
+        ObjectLiteralExpression = 142,

+>ObjectLiteralExpression : SyntaxKind
+
+        PropertyAccessExpression = 143,

+>PropertyAccessExpression : SyntaxKind
+
+        ElementAccessExpression = 144,

+>ElementAccessExpression : SyntaxKind
+
+        CallExpression = 145,

+>CallExpression : SyntaxKind
+
+        NewExpression = 146,

+>NewExpression : SyntaxKind
+
+        TaggedTemplateExpression = 147,

+>TaggedTemplateExpression : SyntaxKind
+
+        TypeAssertionExpression = 148,

+>TypeAssertionExpression : SyntaxKind
+
+        ParenthesizedExpression = 149,

+>ParenthesizedExpression : SyntaxKind
+
+        FunctionExpression = 150,

+>FunctionExpression : SyntaxKind
+
+        ArrowFunction = 151,

+>ArrowFunction : SyntaxKind
+
+        DeleteExpression = 152,

+>DeleteExpression : SyntaxKind
+
+        TypeOfExpression = 153,

+>TypeOfExpression : SyntaxKind
+
+        VoidExpression = 154,

+>VoidExpression : SyntaxKind
+
+        PrefixUnaryExpression = 155,

+>PrefixUnaryExpression : SyntaxKind
+
+        PostfixUnaryExpression = 156,

+>PostfixUnaryExpression : SyntaxKind
+
+        BinaryExpression = 157,

+>BinaryExpression : SyntaxKind
+
+        ConditionalExpression = 158,

+>ConditionalExpression : SyntaxKind
+
+        TemplateExpression = 159,

+>TemplateExpression : SyntaxKind
+
+        YieldExpression = 160,

+>YieldExpression : SyntaxKind
+
+        OmittedExpression = 161,

+>OmittedExpression : SyntaxKind
+
+        TemplateSpan = 162,

+>TemplateSpan : SyntaxKind
+
+        Block = 163,

+>Block : SyntaxKind
+
+        VariableStatement = 164,

+>VariableStatement : SyntaxKind
+
+        EmptyStatement = 165,

+>EmptyStatement : SyntaxKind
+
+        ExpressionStatement = 166,

+>ExpressionStatement : SyntaxKind
+
+        IfStatement = 167,

+>IfStatement : SyntaxKind
+
+        DoStatement = 168,

+>DoStatement : SyntaxKind
+
+        WhileStatement = 169,

+>WhileStatement : SyntaxKind
+
+        ForStatement = 170,

+>ForStatement : SyntaxKind
+
+        ForInStatement = 171,

+>ForInStatement : SyntaxKind
+
+        ContinueStatement = 172,

+>ContinueStatement : SyntaxKind
+
+        BreakStatement = 173,

+>BreakStatement : SyntaxKind
+
+        ReturnStatement = 174,

+>ReturnStatement : SyntaxKind
+
+        WithStatement = 175,

+>WithStatement : SyntaxKind
+
+        SwitchStatement = 176,

+>SwitchStatement : SyntaxKind
+
+        LabeledStatement = 177,

+>LabeledStatement : SyntaxKind
+
+        ThrowStatement = 178,

+>ThrowStatement : SyntaxKind
+
+        TryStatement = 179,

+>TryStatement : SyntaxKind
+
+        TryBlock = 180,

+>TryBlock : SyntaxKind
+
+        FinallyBlock = 181,

+>FinallyBlock : SyntaxKind
+
+        DebuggerStatement = 182,

+>DebuggerStatement : SyntaxKind
+
+        VariableDeclaration = 183,

+>VariableDeclaration : SyntaxKind
+
+        FunctionDeclaration = 184,

+>FunctionDeclaration : SyntaxKind
+
+        ClassDeclaration = 185,

+>ClassDeclaration : SyntaxKind
+
+        InterfaceDeclaration = 186,

+>InterfaceDeclaration : SyntaxKind
+
+        TypeAliasDeclaration = 187,

+>TypeAliasDeclaration : SyntaxKind
+
+        EnumDeclaration = 188,

+>EnumDeclaration : SyntaxKind
+
+        ModuleDeclaration = 189,

+>ModuleDeclaration : SyntaxKind
+
+        ModuleBlock = 190,

+>ModuleBlock : SyntaxKind
+
+        ImportDeclaration = 191,

+>ImportDeclaration : SyntaxKind
+
+        ExportAssignment = 192,

+>ExportAssignment : SyntaxKind
+
+        ExternalModuleReference = 193,

+>ExternalModuleReference : SyntaxKind
+
+        CaseClause = 194,

+>CaseClause : SyntaxKind
+
+        DefaultClause = 195,

+>DefaultClause : SyntaxKind
+
+        HeritageClause = 196,

+>HeritageClause : SyntaxKind
+
+        CatchClause = 197,

+>CatchClause : SyntaxKind
+
+        PropertyAssignment = 198,

+>PropertyAssignment : SyntaxKind
+
+        ShorthandPropertyAssignment = 199,

+>ShorthandPropertyAssignment : SyntaxKind
+
+        EnumMember = 200,

+>EnumMember : SyntaxKind
+
+        SourceFile = 201,

+>SourceFile : SyntaxKind
+
+        Program = 202,

+>Program : SyntaxKind
+
+        SyntaxList = 203,

+>SyntaxList : SyntaxKind
+
+        Count = 204,

+>Count : SyntaxKind
+
+        FirstAssignment = 51,

+>FirstAssignment : SyntaxKind
+
+        LastAssignment = 62,

+>LastAssignment : SyntaxKind
+
+        FirstReservedWord = 64,

+>FirstReservedWord : SyntaxKind
+
+        LastReservedWord = 99,

+>LastReservedWord : SyntaxKind
+
+        FirstKeyword = 64,

+>FirstKeyword : SyntaxKind
+
+        LastKeyword = 119,

+>LastKeyword : SyntaxKind
+
+        FirstFutureReservedWord = 100,

+>FirstFutureReservedWord : SyntaxKind
+
+        LastFutureReservedWord = 108,

+>LastFutureReservedWord : SyntaxKind
+
+        FirstTypeNode = 132,

+>FirstTypeNode : SyntaxKind
+
+        LastTypeNode = 140,

+>LastTypeNode : SyntaxKind
+
+        FirstPunctuation = 13,

+>FirstPunctuation : SyntaxKind
+
+        LastPunctuation = 62,

+>LastPunctuation : SyntaxKind
+
+        FirstToken = 0,

+>FirstToken : SyntaxKind
+
+        LastToken = 119,

+>LastToken : SyntaxKind
+
+        FirstTriviaToken = 2,

+>FirstTriviaToken : SyntaxKind
+
+        LastTriviaToken = 5,

+>LastTriviaToken : SyntaxKind
+
+        FirstLiteralToken = 6,

+>FirstLiteralToken : SyntaxKind
+
+        LastLiteralToken = 9,

+>LastLiteralToken : SyntaxKind
+
+        FirstTemplateToken = 9,

+>FirstTemplateToken : SyntaxKind
+
+        LastTemplateToken = 12,

+>LastTemplateToken : SyntaxKind
+
+        FirstOperator = 21,

+>FirstOperator : SyntaxKind
+
+        LastOperator = 62,

+>LastOperator : SyntaxKind
+
+        FirstBinaryOperator = 23,

+>FirstBinaryOperator : SyntaxKind
+
+        LastBinaryOperator = 62,

+>LastBinaryOperator : SyntaxKind
+
+        FirstNode = 120,

+>FirstNode : SyntaxKind
+    }

+    const enum NodeFlags {

+>NodeFlags : NodeFlags
+
+        Export = 1,

+>Export : NodeFlags
+
+        Ambient = 2,

+>Ambient : NodeFlags
+
+        Public = 16,

+>Public : NodeFlags
+
+        Private = 32,

+>Private : NodeFlags
+
+        Protected = 64,

+>Protected : NodeFlags
+
+        Static = 128,

+>Static : NodeFlags
+
+        MultiLine = 256,

+>MultiLine : NodeFlags
+
+        Synthetic = 512,

+>Synthetic : NodeFlags
+
+        DeclarationFile = 1024,

+>DeclarationFile : NodeFlags
+
+        Let = 2048,

+>Let : NodeFlags
+
+        Const = 4096,

+>Const : NodeFlags
+
+        OctalLiteral = 8192,

+>OctalLiteral : NodeFlags
+
+        Modifier = 243,

+>Modifier : NodeFlags
+
+        AccessibilityModifier = 112,

+>AccessibilityModifier : NodeFlags
+
+        BlockScoped = 6144,

+>BlockScoped : NodeFlags
+    }

+    const enum ParserContextFlags {

+>ParserContextFlags : ParserContextFlags
+
+        StrictMode = 1,

+>StrictMode : ParserContextFlags
+
+        DisallowIn = 2,

+>DisallowIn : ParserContextFlags
+
+        Yield = 4,

+>Yield : ParserContextFlags
+
+        GeneratorParameter = 8,

+>GeneratorParameter : ParserContextFlags
+
+        ContainsError = 16,

+>ContainsError : ParserContextFlags
+
+        HasPropagatedChildContainsErrorFlag = 32,

+>HasPropagatedChildContainsErrorFlag : ParserContextFlags
+    }

+    interface Node extends TextRange {

+>Node : Node
+>TextRange : TextRange
+
+        kind: SyntaxKind;

+>kind : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        flags: NodeFlags;

+>flags : NodeFlags
+>NodeFlags : NodeFlags
+
+        parserContextFlags?: ParserContextFlags;

+>parserContextFlags : ParserContextFlags
+>ParserContextFlags : ParserContextFlags
+
+        id?: number;

+>id : number
+
+        parent?: Node;

+>parent : Node
+>Node : Node
+
+        symbol?: Symbol;

+>symbol : Symbol
+>Symbol : Symbol
+
+        locals?: SymbolTable;

+>locals : SymbolTable
+>SymbolTable : SymbolTable
+
+        nextContainer?: Node;

+>nextContainer : Node
+>Node : Node
+
+        localSymbol?: Symbol;

+>localSymbol : Symbol
+>Symbol : Symbol
+
+        modifiers?: ModifiersArray;

+>modifiers : ModifiersArray
+>ModifiersArray : ModifiersArray
+    }

+    interface NodeArray<T> extends Array<T>, TextRange {

+>NodeArray : NodeArray<T>
+>T : T
+>Array : T[]
+>T : T
+>TextRange : TextRange
+
+        hasTrailingComma?: boolean;

+>hasTrailingComma : boolean
+    }

+    interface ModifiersArray extends NodeArray<Node> {

+>ModifiersArray : ModifiersArray
+>NodeArray : NodeArray<T>
+>Node : Node
+
+        flags: number;

+>flags : number
+    }

+    interface Identifier extends PrimaryExpression {

+>Identifier : Identifier
+>PrimaryExpression : PrimaryExpression
+
+        text: string;

+>text : string
+    }

+    interface QualifiedName extends Node {

+>QualifiedName : QualifiedName
+>Node : Node
+
+        left: EntityName;

+>left : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+
+        right: Identifier;

+>right : Identifier
+>Identifier : Identifier
+    }

+    type EntityName = Identifier | QualifiedName;

+>EntityName : Identifier | QualifiedName
+>Identifier : Identifier
+>QualifiedName : QualifiedName
+
+    type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName;

+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+>Identifier : Identifier
+>LiteralExpression : LiteralExpression
+>ComputedPropertyName : ComputedPropertyName
+
+    interface Declaration extends Node {

+>Declaration : Declaration
+>Node : Node
+
+        _declarationBrand: any;

+>_declarationBrand : any
+
+        name?: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+    }

+    interface ComputedPropertyName extends Node {

+>ComputedPropertyName : ComputedPropertyName
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface TypeParameterDeclaration extends Declaration {

+>TypeParameterDeclaration : TypeParameterDeclaration
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        constraint?: TypeNode;

+>constraint : TypeNode
+>TypeNode : TypeNode
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface SignatureDeclaration extends Declaration {

+>SignatureDeclaration : SignatureDeclaration
+>Declaration : Declaration
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        parameters: NodeArray<ParameterDeclaration>;

+>parameters : NodeArray<ParameterDeclaration>
+>NodeArray : NodeArray<T>
+>ParameterDeclaration : ParameterDeclaration
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface VariableDeclaration extends Declaration {

+>VariableDeclaration : VariableDeclaration
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface ParameterDeclaration extends Declaration {

+>ParameterDeclaration : ParameterDeclaration
+>Declaration : Declaration
+
+        dotDotDotToken?: Node;

+>dotDotDotToken : Node
+>Node : Node
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        type?: TypeNode | StringLiteralExpression;

+>type : TypeNode | StringLiteralExpression
+>TypeNode : TypeNode
+>StringLiteralExpression : StringLiteralExpression
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface PropertyDeclaration extends Declaration, ClassElement {

+>PropertyDeclaration : PropertyDeclaration
+>Declaration : Declaration
+>ClassElement : ClassElement
+
+        _propertyDeclarationBrand: any;

+>_propertyDeclarationBrand : any
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    type VariableOrParameterDeclaration = VariableDeclaration | ParameterDeclaration;

+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>VariableDeclaration : VariableDeclaration
+>ParameterDeclaration : ParameterDeclaration
+
+    type VariableOrParameterOrPropertyDeclaration = VariableOrParameterDeclaration | PropertyDeclaration;

+>VariableOrParameterOrPropertyDeclaration : ParameterDeclaration | VariableDeclaration | PropertyDeclaration
+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>PropertyDeclaration : PropertyDeclaration
+
+    interface ObjectLiteralElement extends Declaration {

+>ObjectLiteralElement : ObjectLiteralElement
+>Declaration : Declaration
+
+        _objectLiteralBrandBrand: any;

+>_objectLiteralBrandBrand : any
+    }

+    interface ShorthandPropertyAssignment extends ObjectLiteralElement {

+>ShorthandPropertyAssignment : ShorthandPropertyAssignment
+>ObjectLiteralElement : ObjectLiteralElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+    }

+    interface PropertyAssignment extends ObjectLiteralElement {

+>PropertyAssignment : PropertyAssignment
+>ObjectLiteralElement : ObjectLiteralElement
+
+        _propertyAssignmentBrand: any;

+>_propertyAssignmentBrand : any
+
+        name: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        initializer: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    /**

+     * Several node kinds share function-like features such as a signature,

+     * a name, and a body. These nodes should extend FunctionLikeDeclaration.

+     * Examples:

+     *  FunctionDeclaration

+     *  MethodDeclaration

+     *  AccessorDeclaration

+     */

+    interface FunctionLikeDeclaration extends SignatureDeclaration {

+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        _functionLikeDeclarationBrand: any;

+>_functionLikeDeclarationBrand : any
+
+        asteriskToken?: Node;

+>asteriskToken : Node
+>Node : Node
+
+        questionToken?: Node;

+>questionToken : Node
+>Node : Node
+
+        body?: Block | Expression;

+>body : Expression | Block
+>Block : Block
+>Expression : Expression
+    }

+    interface FunctionDeclaration extends FunctionLikeDeclaration, Statement {

+>FunctionDeclaration : FunctionDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>Statement : Statement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

+>MethodDeclaration : MethodDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+>ObjectLiteralElement : ObjectLiteralElement
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {

+>ConstructorDeclaration : ConstructorDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+
+        body?: Block;

+>body : Block
+>Block : Block
+    }

+    interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

+>AccessorDeclaration : AccessorDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+>ClassElement : ClassElement
+>ObjectLiteralElement : ObjectLiteralElement
+
+        _accessorDeclarationBrand: any;

+>_accessorDeclarationBrand : any
+
+        body: Block;

+>body : Block
+>Block : Block
+    }

+    interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement {

+>IndexSignatureDeclaration : IndexSignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>ClassElement : ClassElement
+
+        _indexSignatureDeclarationBrand: any;

+>_indexSignatureDeclarationBrand : any
+    }

+    interface TypeNode extends Node {

+>TypeNode : TypeNode
+>Node : Node
+
+        _typeNodeBrand: any;

+>_typeNodeBrand : any
+    }

+    interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {

+>FunctionOrConstructorTypeNode : FunctionOrConstructorTypeNode
+>TypeNode : TypeNode
+>SignatureDeclaration : SignatureDeclaration
+
+        _functionOrConstructorTypeNodeBrand: any;

+>_functionOrConstructorTypeNodeBrand : any
+    }

+    interface TypeReferenceNode extends TypeNode {

+>TypeReferenceNode : TypeReferenceNode
+>TypeNode : TypeNode
+
+        typeName: EntityName;

+>typeName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+
+        typeArguments?: NodeArray<TypeNode>;

+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface TypeQueryNode extends TypeNode {

+>TypeQueryNode : TypeQueryNode
+>TypeNode : TypeNode
+
+        exprName: EntityName;

+>exprName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+    }

+    interface TypeLiteralNode extends TypeNode, Declaration {

+>TypeLiteralNode : TypeLiteralNode
+>TypeNode : TypeNode
+>Declaration : Declaration
+
+        members: NodeArray<Node>;

+>members : NodeArray<Node>
+>NodeArray : NodeArray<T>
+>Node : Node
+    }

+    interface ArrayTypeNode extends TypeNode {

+>ArrayTypeNode : ArrayTypeNode
+>TypeNode : TypeNode
+
+        elementType: TypeNode;

+>elementType : TypeNode
+>TypeNode : TypeNode
+    }

+    interface TupleTypeNode extends TypeNode {

+>TupleTypeNode : TupleTypeNode
+>TypeNode : TypeNode
+
+        elementTypes: NodeArray<TypeNode>;

+>elementTypes : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface UnionTypeNode extends TypeNode {

+>UnionTypeNode : UnionTypeNode
+>TypeNode : TypeNode
+
+        types: NodeArray<TypeNode>;

+>types : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+    }

+    interface ParenthesizedTypeNode extends TypeNode {

+>ParenthesizedTypeNode : ParenthesizedTypeNode
+>TypeNode : TypeNode
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface Expression extends Node {

+>Expression : Expression
+>Node : Node
+
+        _expressionBrand: any;

+>_expressionBrand : any
+
+        contextualType?: Type;

+>contextualType : Type
+>Type : Type
+    }

+    interface UnaryExpression extends Expression {

+>UnaryExpression : UnaryExpression
+>Expression : Expression
+
+        _unaryExpressionBrand: any;

+>_unaryExpressionBrand : any
+    }

+    interface PrefixUnaryExpression extends UnaryExpression {

+>PrefixUnaryExpression : PrefixUnaryExpression
+>UnaryExpression : UnaryExpression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        operand: UnaryExpression;

+>operand : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface PostfixUnaryExpression extends PostfixExpression {

+>PostfixUnaryExpression : PostfixUnaryExpression
+>PostfixExpression : PostfixExpression
+
+        operand: LeftHandSideExpression;

+>operand : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+    }

+    interface PostfixExpression extends UnaryExpression {

+>PostfixExpression : PostfixExpression
+>UnaryExpression : UnaryExpression
+
+        _postfixExpressionBrand: any;

+>_postfixExpressionBrand : any
+    }

+    interface LeftHandSideExpression extends PostfixExpression {

+>LeftHandSideExpression : LeftHandSideExpression
+>PostfixExpression : PostfixExpression
+
+        _leftHandSideExpressionBrand: any;

+>_leftHandSideExpressionBrand : any
+    }

+    interface MemberExpression extends LeftHandSideExpression {

+>MemberExpression : MemberExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        _memberExpressionBrand: any;

+>_memberExpressionBrand : any
+    }

+    interface PrimaryExpression extends MemberExpression {

+>PrimaryExpression : PrimaryExpression
+>MemberExpression : MemberExpression
+
+        _primaryExpressionBrand: any;

+>_primaryExpressionBrand : any
+    }

+    interface DeleteExpression extends UnaryExpression {

+>DeleteExpression : DeleteExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface TypeOfExpression extends UnaryExpression {

+>TypeOfExpression : TypeOfExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface VoidExpression extends UnaryExpression {

+>VoidExpression : VoidExpression
+>UnaryExpression : UnaryExpression
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface YieldExpression extends Expression {

+>YieldExpression : YieldExpression
+>Expression : Expression
+
+        asteriskToken?: Node;

+>asteriskToken : Node
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface BinaryExpression extends Expression {

+>BinaryExpression : BinaryExpression
+>Expression : Expression
+
+        left: Expression;

+>left : Expression
+>Expression : Expression
+
+        operator: SyntaxKind;

+>operator : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        right: Expression;

+>right : Expression
+>Expression : Expression
+    }

+    interface ConditionalExpression extends Expression {

+>ConditionalExpression : ConditionalExpression
+>Expression : Expression
+
+        condition: Expression;

+>condition : Expression
+>Expression : Expression
+
+        whenTrue: Expression;

+>whenTrue : Expression
+>Expression : Expression
+
+        whenFalse: Expression;

+>whenFalse : Expression
+>Expression : Expression
+    }

+    interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {

+>FunctionExpression : FunctionExpression
+>PrimaryExpression : PrimaryExpression
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        name?: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        body: Block | Expression;

+>body : Expression | Block
+>Block : Block
+>Expression : Expression
+    }

+    interface LiteralExpression extends PrimaryExpression {

+>LiteralExpression : LiteralExpression
+>PrimaryExpression : PrimaryExpression
+
+        text: string;

+>text : string
+
+        isUnterminated?: boolean;

+>isUnterminated : boolean
+    }

+    interface StringLiteralExpression extends LiteralExpression {

+>StringLiteralExpression : StringLiteralExpression
+>LiteralExpression : LiteralExpression
+
+        _stringLiteralExpressionBrand: any;

+>_stringLiteralExpressionBrand : any
+    }

+    interface TemplateExpression extends PrimaryExpression {

+>TemplateExpression : TemplateExpression
+>PrimaryExpression : PrimaryExpression
+
+        head: LiteralExpression;

+>head : LiteralExpression
+>LiteralExpression : LiteralExpression
+
+        templateSpans: NodeArray<TemplateSpan>;

+>templateSpans : NodeArray<TemplateSpan>
+>NodeArray : NodeArray<T>
+>TemplateSpan : TemplateSpan
+    }

+    interface TemplateSpan extends Node {

+>TemplateSpan : TemplateSpan
+>Node : Node
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        literal: LiteralExpression;

+>literal : LiteralExpression
+>LiteralExpression : LiteralExpression
+    }

+    interface ParenthesizedExpression extends PrimaryExpression {

+>ParenthesizedExpression : ParenthesizedExpression
+>PrimaryExpression : PrimaryExpression
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ArrayLiteralExpression extends PrimaryExpression {

+>ArrayLiteralExpression : ArrayLiteralExpression
+>PrimaryExpression : PrimaryExpression
+
+        elements: NodeArray<Expression>;

+>elements : NodeArray<Expression>
+>NodeArray : NodeArray<T>
+>Expression : Expression
+    }

+    interface ObjectLiteralExpression extends PrimaryExpression, Declaration {

+>ObjectLiteralExpression : ObjectLiteralExpression
+>PrimaryExpression : PrimaryExpression
+>Declaration : Declaration
+
+        properties: NodeArray<ObjectLiteralElement>;

+>properties : NodeArray<ObjectLiteralElement>
+>NodeArray : NodeArray<T>
+>ObjectLiteralElement : ObjectLiteralElement
+    }

+    interface PropertyAccessExpression extends MemberExpression {

+>PropertyAccessExpression : PropertyAccessExpression
+>MemberExpression : MemberExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+    }

+    interface ElementAccessExpression extends MemberExpression {

+>ElementAccessExpression : ElementAccessExpression
+>MemberExpression : MemberExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        argumentExpression?: Expression;

+>argumentExpression : Expression
+>Expression : Expression
+    }

+    interface CallExpression extends LeftHandSideExpression {

+>CallExpression : CallExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        expression: LeftHandSideExpression;

+>expression : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        typeArguments?: NodeArray<TypeNode>;

+>typeArguments : NodeArray<TypeNode>
+>NodeArray : NodeArray<T>
+>TypeNode : TypeNode
+
+        arguments: NodeArray<Expression>;

+>arguments : NodeArray<Expression>
+>NodeArray : NodeArray<T>
+>Expression : Expression
+    }

+    interface NewExpression extends CallExpression, PrimaryExpression {

+>NewExpression : NewExpression
+>CallExpression : CallExpression
+>PrimaryExpression : PrimaryExpression
+    }

+    interface TaggedTemplateExpression extends MemberExpression {

+>TaggedTemplateExpression : TaggedTemplateExpression
+>MemberExpression : MemberExpression
+
+        tag: LeftHandSideExpression;

+>tag : LeftHandSideExpression
+>LeftHandSideExpression : LeftHandSideExpression
+
+        template: LiteralExpression | TemplateExpression;

+>template : LiteralExpression | TemplateExpression
+>LiteralExpression : LiteralExpression
+>TemplateExpression : TemplateExpression
+    }

+    type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;

+>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression
+>CallExpression : CallExpression
+>NewExpression : NewExpression
+>TaggedTemplateExpression : TaggedTemplateExpression
+
+    interface TypeAssertion extends UnaryExpression {

+>TypeAssertion : TypeAssertion
+>UnaryExpression : UnaryExpression
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        expression: UnaryExpression;

+>expression : UnaryExpression
+>UnaryExpression : UnaryExpression
+    }

+    interface Statement extends Node, ModuleElement {

+>Statement : Statement
+>Node : Node
+>ModuleElement : ModuleElement
+
+        _statementBrand: any;

+>_statementBrand : any
+    }

+    interface Block extends Statement {

+>Block : Block
+>Statement : Statement
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    interface VariableStatement extends Statement {

+>VariableStatement : VariableStatement
+>Statement : Statement
+
+        declarations: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+    }

+    interface ExpressionStatement extends Statement {

+>ExpressionStatement : ExpressionStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface IfStatement extends Statement {

+>IfStatement : IfStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        thenStatement: Statement;

+>thenStatement : Statement
+>Statement : Statement
+
+        elseStatement?: Statement;

+>elseStatement : Statement
+>Statement : Statement
+    }

+    interface IterationStatement extends Statement {

+>IterationStatement : IterationStatement
+>Statement : Statement
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface DoStatement extends IterationStatement {

+>DoStatement : DoStatement
+>IterationStatement : IterationStatement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface WhileStatement extends IterationStatement {

+>WhileStatement : WhileStatement
+>IterationStatement : IterationStatement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ForStatement extends IterationStatement {

+>ForStatement : ForStatement
+>IterationStatement : IterationStatement
+
+        declarations?: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+
+        condition?: Expression;

+>condition : Expression
+>Expression : Expression
+
+        iterator?: Expression;

+>iterator : Expression
+>Expression : Expression
+    }

+    interface ForInStatement extends IterationStatement {

+>ForInStatement : ForInStatement
+>IterationStatement : IterationStatement
+
+        declarations?: NodeArray<VariableDeclaration>;

+>declarations : NodeArray<VariableDeclaration>
+>NodeArray : NodeArray<T>
+>VariableDeclaration : VariableDeclaration
+
+        variable?: Expression;

+>variable : Expression
+>Expression : Expression
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface BreakOrContinueStatement extends Statement {

+>BreakOrContinueStatement : BreakOrContinueStatement
+>Statement : Statement
+
+        label?: Identifier;

+>label : Identifier
+>Identifier : Identifier
+    }

+    interface ReturnStatement extends Statement {

+>ReturnStatement : ReturnStatement
+>Statement : Statement
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface WithStatement extends Statement {

+>WithStatement : WithStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface SwitchStatement extends Statement {

+>SwitchStatement : SwitchStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+
+        clauses: NodeArray<CaseOrDefaultClause>;

+>clauses : NodeArray<CaseClause | DefaultClause>
+>NodeArray : NodeArray<T>
+>CaseOrDefaultClause : CaseClause | DefaultClause
+    }

+    interface CaseClause extends Node {

+>CaseClause : CaseClause
+>Node : Node
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    interface DefaultClause extends Node {

+>DefaultClause : DefaultClause
+>Node : Node
+
+        statements: NodeArray<Statement>;

+>statements : NodeArray<Statement>
+>NodeArray : NodeArray<T>
+>Statement : Statement
+    }

+    type CaseOrDefaultClause = CaseClause | DefaultClause;

+>CaseOrDefaultClause : CaseClause | DefaultClause
+>CaseClause : CaseClause
+>DefaultClause : DefaultClause
+
+    interface LabeledStatement extends Statement {

+>LabeledStatement : LabeledStatement
+>Statement : Statement
+
+        label: Identifier;

+>label : Identifier
+>Identifier : Identifier
+
+        statement: Statement;

+>statement : Statement
+>Statement : Statement
+    }

+    interface ThrowStatement extends Statement {

+>ThrowStatement : ThrowStatement
+>Statement : Statement
+
+        expression: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface TryStatement extends Statement {

+>TryStatement : TryStatement
+>Statement : Statement
+
+        tryBlock: Block;

+>tryBlock : Block
+>Block : Block
+
+        catchClause?: CatchClause;

+>catchClause : CatchClause
+>CatchClause : CatchClause
+
+        finallyBlock?: Block;

+>finallyBlock : Block
+>Block : Block
+    }

+    interface CatchClause extends Declaration {

+>CatchClause : CatchClause
+>Declaration : Declaration
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type?: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+
+        block: Block;

+>block : Block
+>Block : Block
+    }

+    interface ModuleElement extends Node {

+>ModuleElement : ModuleElement
+>Node : Node
+
+        _moduleElementBrand: any;

+>_moduleElementBrand : any
+    }

+    interface ClassDeclaration extends Declaration, ModuleElement {

+>ClassDeclaration : ClassDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        heritageClauses?: NodeArray<HeritageClause>;

+>heritageClauses : NodeArray<HeritageClause>
+>NodeArray : NodeArray<T>
+>HeritageClause : HeritageClause
+
+        members: NodeArray<ClassElement>;

+>members : NodeArray<ClassElement>
+>NodeArray : NodeArray<T>
+>ClassElement : ClassElement
+    }

+    interface ClassElement extends Declaration {

+>ClassElement : ClassElement
+>Declaration : Declaration
+
+        _classElementBrand: any;

+>_classElementBrand : any
+    }

+    interface InterfaceDeclaration extends Declaration, ModuleElement {

+>InterfaceDeclaration : InterfaceDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        typeParameters?: NodeArray<TypeParameterDeclaration>;

+>typeParameters : NodeArray<TypeParameterDeclaration>
+>NodeArray : NodeArray<T>
+>TypeParameterDeclaration : TypeParameterDeclaration
+
+        heritageClauses?: NodeArray<HeritageClause>;

+>heritageClauses : NodeArray<HeritageClause>
+>NodeArray : NodeArray<T>
+>HeritageClause : HeritageClause
+
+        members: NodeArray<Declaration>;

+>members : NodeArray<Declaration>
+>NodeArray : NodeArray<T>
+>Declaration : Declaration
+    }

+    interface HeritageClause extends Node {

+>HeritageClause : HeritageClause
+>Node : Node
+
+        token: SyntaxKind;

+>token : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        types?: NodeArray<TypeReferenceNode>;

+>types : NodeArray<TypeReferenceNode>
+>NodeArray : NodeArray<T>
+>TypeReferenceNode : TypeReferenceNode
+    }

+    interface TypeAliasDeclaration extends Declaration, ModuleElement {

+>TypeAliasDeclaration : TypeAliasDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        type: TypeNode;

+>type : TypeNode
+>TypeNode : TypeNode
+    }

+    interface EnumMember extends Declaration {

+>EnumMember : EnumMember
+>Declaration : Declaration
+
+        name: DeclarationName;

+>name : Identifier | LiteralExpression | ComputedPropertyName
+>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName
+
+        initializer?: Expression;

+>initializer : Expression
+>Expression : Expression
+    }

+    interface EnumDeclaration extends Declaration, ModuleElement {

+>EnumDeclaration : EnumDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        members: NodeArray<EnumMember>;

+>members : NodeArray<EnumMember>
+>NodeArray : NodeArray<T>
+>EnumMember : EnumMember
+    }

+    interface ModuleDeclaration extends Declaration, ModuleElement {

+>ModuleDeclaration : ModuleDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier | LiteralExpression;

+>name : Identifier | LiteralExpression
+>Identifier : Identifier
+>LiteralExpression : LiteralExpression
+
+        body: ModuleBlock | ModuleDeclaration;

+>body : ModuleDeclaration | ModuleBlock
+>ModuleBlock : ModuleBlock
+>ModuleDeclaration : ModuleDeclaration
+    }

+    interface ModuleBlock extends Node, ModuleElement {

+>ModuleBlock : ModuleBlock
+>Node : Node
+>ModuleElement : ModuleElement
+
+        statements: NodeArray<ModuleElement>;

+>statements : NodeArray<ModuleElement>
+>NodeArray : NodeArray<T>
+>ModuleElement : ModuleElement
+    }

+    interface ImportDeclaration extends Declaration, ModuleElement {

+>ImportDeclaration : ImportDeclaration
+>Declaration : Declaration
+>ModuleElement : ModuleElement
+
+        name: Identifier;

+>name : Identifier
+>Identifier : Identifier
+
+        moduleReference: EntityName | ExternalModuleReference;

+>moduleReference : Identifier | QualifiedName | ExternalModuleReference
+>EntityName : Identifier | QualifiedName
+>ExternalModuleReference : ExternalModuleReference
+    }

+    interface ExternalModuleReference extends Node {

+>ExternalModuleReference : ExternalModuleReference
+>Node : Node
+
+        expression?: Expression;

+>expression : Expression
+>Expression : Expression
+    }

+    interface ExportAssignment extends Statement, ModuleElement {

+>ExportAssignment : ExportAssignment
+>Statement : Statement
+>ModuleElement : ModuleElement
+
+        exportName: Identifier;

+>exportName : Identifier
+>Identifier : Identifier
+    }

+    interface FileReference extends TextRange {

+>FileReference : FileReference
+>TextRange : TextRange
+
+        filename: string;

+>filename : string
+    }

+    interface CommentRange extends TextRange {

+>CommentRange : CommentRange
+>TextRange : TextRange
+
+        hasTrailingNewLine?: boolean;

+>hasTrailingNewLine : boolean
+    }

+    interface SourceFile extends Declaration {

+>SourceFile : SourceFile
+>Declaration : Declaration
+
+        statements: NodeArray<ModuleElement>;

+>statements : NodeArray<ModuleElement>
+>NodeArray : NodeArray<T>
+>ModuleElement : ModuleElement
+
+        endOfFileToken: Node;

+>endOfFileToken : Node
+>Node : Node
+
+        filename: string;

+>filename : string
+
+        text: string;

+>text : string
+
+        getLineAndCharacterFromPosition(position: number): LineAndCharacter;

+>getLineAndCharacterFromPosition : (position: number) => LineAndCharacter
+>position : number
+>LineAndCharacter : LineAndCharacter
+
+        getPositionFromLineAndCharacter(line: number, character: number): number;

+>getPositionFromLineAndCharacter : (line: number, character: number) => number
+>line : number
+>character : number
+
+        getLineStarts(): number[];

+>getLineStarts : () => number[]
+
+        amdDependencies: string[];

+>amdDependencies : string[]
+
+        amdModuleName: string;

+>amdModuleName : string
+
+        referencedFiles: FileReference[];

+>referencedFiles : FileReference[]
+>FileReference : FileReference
+
+        referenceDiagnostics: Diagnostic[];

+>referenceDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        parseDiagnostics: Diagnostic[];

+>parseDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        grammarDiagnostics: Diagnostic[];

+>grammarDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getSyntacticDiagnostics(): Diagnostic[];

+>getSyntacticDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        semanticDiagnostics: Diagnostic[];

+>semanticDiagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        hasNoDefaultLib: boolean;

+>hasNoDefaultLib : boolean
+
+        externalModuleIndicator: Node;

+>externalModuleIndicator : Node
+>Node : Node
+
+        nodeCount: number;

+>nodeCount : number
+
+        identifierCount: number;

+>identifierCount : number
+
+        symbolCount: number;

+>symbolCount : number
+
+        isOpen: boolean;

+>isOpen : boolean
+
+        version: string;

+>version : string
+
+        languageVersion: ScriptTarget;

+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+        identifiers: Map<string>;

+>identifiers : Map<string>
+>Map : Map<T>
+    }

+    interface Program {

+>Program : Program
+
+        getSourceFile(filename: string): SourceFile;

+>getSourceFile : (filename: string) => SourceFile
+>filename : string
+>SourceFile : SourceFile
+
+        getSourceFiles(): SourceFile[];

+>getSourceFiles : () => SourceFile[]
+>SourceFile : SourceFile
+
+        getCompilerOptions(): CompilerOptions;

+>getCompilerOptions : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getCompilerHost(): CompilerHost;

+>getCompilerHost : () => CompilerHost
+>CompilerHost : CompilerHost
+
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

+>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getGlobalDiagnostics(): Diagnostic[];

+>getGlobalDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getTypeChecker(fullTypeCheckMode: boolean): TypeChecker;

+>getTypeChecker : (fullTypeCheckMode: boolean) => TypeChecker
+>fullTypeCheckMode : boolean
+>TypeChecker : TypeChecker
+
+        getCommonSourceDirectory(): string;

+>getCommonSourceDirectory : () => string
+    }

+    interface SourceMapSpan {

+>SourceMapSpan : SourceMapSpan
+
+        emittedLine: number;

+>emittedLine : number
+
+        emittedColumn: number;

+>emittedColumn : number
+
+        sourceLine: number;

+>sourceLine : number
+
+        sourceColumn: number;

+>sourceColumn : number
+
+        nameIndex?: number;

+>nameIndex : number
+
+        sourceIndex: number;

+>sourceIndex : number
+    }

+    interface SourceMapData {

+>SourceMapData : SourceMapData
+
+        sourceMapFilePath: string;

+>sourceMapFilePath : string
+
+        jsSourceMappingURL: string;

+>jsSourceMappingURL : string
+
+        sourceMapFile: string;

+>sourceMapFile : string
+
+        sourceMapSourceRoot: string;

+>sourceMapSourceRoot : string
+
+        sourceMapSources: string[];

+>sourceMapSources : string[]
+
+        inputSourceFileNames: string[];

+>inputSourceFileNames : string[]
+
+        sourceMapNames?: string[];

+>sourceMapNames : string[]
+
+        sourceMapMappings: string;

+>sourceMapMappings : string
+
+        sourceMapDecodedMappings: SourceMapSpan[];

+>sourceMapDecodedMappings : SourceMapSpan[]
+>SourceMapSpan : SourceMapSpan
+    }

+    enum EmitReturnStatus {

+>EmitReturnStatus : EmitReturnStatus
+
+        Succeeded = 0,

+>Succeeded : EmitReturnStatus
+
+        AllOutputGenerationSkipped = 1,

+>AllOutputGenerationSkipped : EmitReturnStatus
+
+        JSGeneratedWithSemanticErrors = 2,

+>JSGeneratedWithSemanticErrors : EmitReturnStatus
+
+        DeclarationGenerationSkipped = 3,

+>DeclarationGenerationSkipped : EmitReturnStatus
+
+        EmitErrorsEncountered = 4,

+>EmitErrorsEncountered : EmitReturnStatus
+
+        CompilerOptionsErrors = 5,

+>CompilerOptionsErrors : EmitReturnStatus
+    }

+    interface EmitResult {

+>EmitResult : EmitResult
+
+        emitResultStatus: EmitReturnStatus;

+>emitResultStatus : EmitReturnStatus
+>EmitReturnStatus : EmitReturnStatus
+
+        diagnostics: Diagnostic[];

+>diagnostics : Diagnostic[]
+>Diagnostic : Diagnostic
+
+        sourceMaps: SourceMapData[];

+>sourceMaps : SourceMapData[]
+>SourceMapData : SourceMapData
+    }

+    interface TypeChecker {

+>TypeChecker : TypeChecker
+
+        getProgram(): Program;

+>getProgram : () => Program
+>Program : Program
+
+        getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

+>getDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getDeclarationDiagnostics(sourceFile: SourceFile): Diagnostic[];

+>getDeclarationDiagnostics : (sourceFile: SourceFile) => Diagnostic[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Diagnostic : Diagnostic
+
+        getGlobalDiagnostics(): Diagnostic[];

+>getGlobalDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getNodeCount(): number;

+>getNodeCount : () => number
+
+        getIdentifierCount(): number;

+>getIdentifierCount : () => number
+
+        getSymbolCount(): number;

+>getSymbolCount : () => number
+
+        getTypeCount(): number;

+>getTypeCount : () => number
+
+        emitFiles(targetSourceFile?: SourceFile): EmitResult;

+>emitFiles : (targetSourceFile?: SourceFile) => EmitResult
+>targetSourceFile : SourceFile
+>SourceFile : SourceFile
+>EmitResult : EmitResult
+
+        getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;

+>getTypeOfSymbolAtLocation : (symbol: Symbol, node: Node) => Type
+>symbol : Symbol
+>Symbol : Symbol
+>node : Node
+>Node : Node
+>Type : Type
+
+        getDeclaredTypeOfSymbol(symbol: Symbol): Type;

+>getDeclaredTypeOfSymbol : (symbol: Symbol) => Type
+>symbol : Symbol
+>Symbol : Symbol
+>Type : Type
+
+        getPropertiesOfType(type: Type): Symbol[];

+>getPropertiesOfType : (type: Type) => Symbol[]
+>type : Type
+>Type : Type
+>Symbol : Symbol
+
+        getPropertyOfType(type: Type, propertyName: string): Symbol;

+>getPropertyOfType : (type: Type, propertyName: string) => Symbol
+>type : Type
+>Type : Type
+>propertyName : string
+>Symbol : Symbol
+
+        getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];

+>getSignaturesOfType : (type: Type, kind: SignatureKind) => Signature[]
+>type : Type
+>Type : Type
+>kind : SignatureKind
+>SignatureKind : SignatureKind
+>Signature : Signature
+
+        getIndexTypeOfType(type: Type, kind: IndexKind): Type;

+>getIndexTypeOfType : (type: Type, kind: IndexKind) => Type
+>type : Type
+>Type : Type
+>kind : IndexKind
+>IndexKind : IndexKind
+>Type : Type
+
+        getReturnTypeOfSignature(signature: Signature): Type;

+>getReturnTypeOfSignature : (signature: Signature) => Type
+>signature : Signature
+>Signature : Signature
+>Type : Type
+
+        getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];

+>getSymbolsInScope : (location: Node, meaning: SymbolFlags) => Symbol[]
+>location : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>Symbol : Symbol
+
+        getSymbolAtLocation(node: Node): Symbol;

+>getSymbolAtLocation : (node: Node) => Symbol
+>node : Node
+>Node : Node
+>Symbol : Symbol
+
+        getShorthandAssignmentValueSymbol(location: Node): Symbol;

+>getShorthandAssignmentValueSymbol : (location: Node) => Symbol
+>location : Node
+>Node : Node
+>Symbol : Symbol
+
+        getTypeAtLocation(node: Node): Type;

+>getTypeAtLocation : (node: Node) => Type
+>node : Node
+>Node : Node
+>Type : Type
+
+        typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;

+>typeToString : (type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => string
+>type : Type
+>Type : Type
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;

+>symbolToString : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => string
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        getSymbolDisplayBuilder(): SymbolDisplayBuilder;

+>getSymbolDisplayBuilder : () => SymbolDisplayBuilder
+>SymbolDisplayBuilder : SymbolDisplayBuilder
+
+        getFullyQualifiedName(symbol: Symbol): string;

+>getFullyQualifiedName : (symbol: Symbol) => string
+>symbol : Symbol
+>Symbol : Symbol
+
+        getAugmentedPropertiesOfType(type: Type): Symbol[];

+>getAugmentedPropertiesOfType : (type: Type) => Symbol[]
+>type : Type
+>Type : Type
+>Symbol : Symbol
+
+        getRootSymbols(symbol: Symbol): Symbol[];

+>getRootSymbols : (symbol: Symbol) => Symbol[]
+>symbol : Symbol
+>Symbol : Symbol
+>Symbol : Symbol
+
+        getContextualType(node: Expression): Type;

+>getContextualType : (node: Expression) => Type
+>node : Expression
+>Expression : Expression
+>Type : Type
+
+        getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;

+>getResolvedSignature : (node: CallExpression | NewExpression | TaggedTemplateExpression, candidatesOutArray?: Signature[]) => Signature
+>node : CallExpression | NewExpression | TaggedTemplateExpression
+>CallLikeExpression : CallExpression | NewExpression | TaggedTemplateExpression
+>candidatesOutArray : Signature[]
+>Signature : Signature
+>Signature : Signature
+
+        getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;

+>getSignatureFromDeclaration : (declaration: SignatureDeclaration) => Signature
+>declaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>Signature : Signature
+
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;

+>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean
+>node : FunctionLikeDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        isUndefinedSymbol(symbol: Symbol): boolean;

+>isUndefinedSymbol : (symbol: Symbol) => boolean
+>symbol : Symbol
+>Symbol : Symbol
+
+        isArgumentsSymbol(symbol: Symbol): boolean;

+>isArgumentsSymbol : (symbol: Symbol) => boolean
+>symbol : Symbol
+>Symbol : Symbol
+
+        isEmitBlocked(sourceFile?: SourceFile): boolean;

+>isEmitBlocked : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getEnumMemberValue(node: EnumMember): number;

+>getEnumMemberValue : (node: EnumMember) => number
+>node : EnumMember
+>EnumMember : EnumMember
+
+        isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;

+>isValidPropertyAccess : (node: QualifiedName | PropertyAccessExpression, propertyName: string) => boolean
+>node : QualifiedName | PropertyAccessExpression
+>PropertyAccessExpression : PropertyAccessExpression
+>QualifiedName : QualifiedName
+>propertyName : string
+
+        getAliasedSymbol(symbol: Symbol): Symbol;

+>getAliasedSymbol : (symbol: Symbol) => Symbol
+>symbol : Symbol
+>Symbol : Symbol
+>Symbol : Symbol
+    }

+    interface SymbolDisplayBuilder {

+>SymbolDisplayBuilder : SymbolDisplayBuilder
+
+        buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildTypeDisplay : (type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>type : Type
+>Type : Type
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;

+>buildSymbolDisplay : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>flags : SymbolFormatFlags
+>SymbolFormatFlags : SymbolFormatFlags
+
+        buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildSignatureDisplay : (signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>signatures : Signature
+>Signature : Signature
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildParameterDisplay : (parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>parameter : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildTypeParameterDisplay : (tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>tp : TypeParameter
+>TypeParameter : TypeParameter
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags): void;

+>buildTypeParameterDisplayFromSymbol : (symbol: Symbol, writer: SymbolWriter, enclosingDeclaraiton?: Node, flags?: TypeFormatFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaraiton : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildDisplayForParametersAndDelimiters(parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildDisplayForParametersAndDelimiters : (parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>parameters : Symbol[]
+>Symbol : Symbol
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildDisplayForTypeParametersAndDelimiters : (typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+
+        buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;

+>buildReturnTypeDisplay : (signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags) => void
+>signature : Signature
+>Signature : Signature
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+    }

+    interface SymbolWriter {

+>SymbolWriter : SymbolWriter
+
+        writeKeyword(text: string): void;

+>writeKeyword : (text: string) => void
+>text : string
+
+        writeOperator(text: string): void;

+>writeOperator : (text: string) => void
+>text : string
+
+        writePunctuation(text: string): void;

+>writePunctuation : (text: string) => void
+>text : string
+
+        writeSpace(text: string): void;

+>writeSpace : (text: string) => void
+>text : string
+
+        writeStringLiteral(text: string): void;

+>writeStringLiteral : (text: string) => void
+>text : string
+
+        writeParameter(text: string): void;

+>writeParameter : (text: string) => void
+>text : string
+
+        writeSymbol(text: string, symbol: Symbol): void;

+>writeSymbol : (text: string, symbol: Symbol) => void
+>text : string
+>symbol : Symbol
+>Symbol : Symbol
+
+        writeLine(): void;

+>writeLine : () => void
+
+        increaseIndent(): void;

+>increaseIndent : () => void
+
+        decreaseIndent(): void;

+>decreaseIndent : () => void
+
+        clear(): void;

+>clear : () => void
+
+        trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;

+>trackSymbol : (symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags) => void
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+    }

+    const enum TypeFormatFlags {

+>TypeFormatFlags : TypeFormatFlags
+
+        None = 0,

+>None : TypeFormatFlags
+
+        WriteArrayAsGenericType = 1,

+>WriteArrayAsGenericType : TypeFormatFlags
+
+        UseTypeOfFunction = 2,

+>UseTypeOfFunction : TypeFormatFlags
+
+        NoTruncation = 4,

+>NoTruncation : TypeFormatFlags
+
+        WriteArrowStyleSignature = 8,

+>WriteArrowStyleSignature : TypeFormatFlags
+
+        WriteOwnNameForAnyLike = 16,

+>WriteOwnNameForAnyLike : TypeFormatFlags
+
+        WriteTypeArgumentsOfSignature = 32,

+>WriteTypeArgumentsOfSignature : TypeFormatFlags
+
+        InElementType = 64,

+>InElementType : TypeFormatFlags
+    }

+    const enum SymbolFormatFlags {

+>SymbolFormatFlags : SymbolFormatFlags
+
+        None = 0,

+>None : SymbolFormatFlags
+
+        WriteTypeParametersOrArguments = 1,

+>WriteTypeParametersOrArguments : SymbolFormatFlags
+
+        UseOnlyExternalAliasing = 2,

+>UseOnlyExternalAliasing : SymbolFormatFlags
+    }

+    const enum SymbolAccessibility {

+>SymbolAccessibility : SymbolAccessibility
+
+        Accessible = 0,

+>Accessible : SymbolAccessibility
+
+        NotAccessible = 1,

+>NotAccessible : SymbolAccessibility
+
+        CannotBeNamed = 2,

+>CannotBeNamed : SymbolAccessibility
+    }

+    interface SymbolVisibilityResult {

+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        accessibility: SymbolAccessibility;

+>accessibility : SymbolAccessibility
+>SymbolAccessibility : SymbolAccessibility
+
+        aliasesToMakeVisible?: ImportDeclaration[];

+>aliasesToMakeVisible : ImportDeclaration[]
+>ImportDeclaration : ImportDeclaration
+
+        errorSymbolName?: string;

+>errorSymbolName : string
+
+        errorNode?: Node;

+>errorNode : Node
+>Node : Node
+    }

+    interface SymbolAccessiblityResult extends SymbolVisibilityResult {

+>SymbolAccessiblityResult : SymbolAccessiblityResult
+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        errorModuleName?: string;

+>errorModuleName : string
+    }

+    interface EmitResolver {

+>EmitResolver : EmitResolver
+
+        getProgram(): Program;

+>getProgram : () => Program
+>Program : Program
+
+        getLocalNameOfContainer(container: ModuleDeclaration | EnumDeclaration): string;

+>getLocalNameOfContainer : (container: EnumDeclaration | ModuleDeclaration) => string
+>container : EnumDeclaration | ModuleDeclaration
+>ModuleDeclaration : ModuleDeclaration
+>EnumDeclaration : EnumDeclaration
+
+        getExpressionNamePrefix(node: Identifier): string;

+>getExpressionNamePrefix : (node: Identifier) => string
+>node : Identifier
+>Identifier : Identifier
+
+        getExportAssignmentName(node: SourceFile): string;

+>getExportAssignmentName : (node: SourceFile) => string
+>node : SourceFile
+>SourceFile : SourceFile
+
+        isReferencedImportDeclaration(node: ImportDeclaration): boolean;

+>isReferencedImportDeclaration : (node: ImportDeclaration) => boolean
+>node : ImportDeclaration
+>ImportDeclaration : ImportDeclaration
+
+        isTopLevelValueImportWithEntityName(node: ImportDeclaration): boolean;

+>isTopLevelValueImportWithEntityName : (node: ImportDeclaration) => boolean
+>node : ImportDeclaration
+>ImportDeclaration : ImportDeclaration
+
+        getNodeCheckFlags(node: Node): NodeCheckFlags;

+>getNodeCheckFlags : (node: Node) => NodeCheckFlags
+>node : Node
+>Node : Node
+>NodeCheckFlags : NodeCheckFlags
+
+        getEnumMemberValue(node: EnumMember): number;

+>getEnumMemberValue : (node: EnumMember) => number
+>node : EnumMember
+>EnumMember : EnumMember
+
+        hasSemanticErrors(sourceFile?: SourceFile): boolean;

+>hasSemanticErrors : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        isDeclarationVisible(node: Declaration): boolean;

+>isDeclarationVisible : (node: Declaration) => boolean
+>node : Declaration
+>Declaration : Declaration
+
+        isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;

+>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean
+>node : FunctionLikeDeclaration
+>FunctionLikeDeclaration : FunctionLikeDeclaration
+
+        writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableOrParameterDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;

+>writeTypeOfDeclaration : (declaration: ParameterDeclaration | VariableDeclaration | AccessorDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
+>declaration : ParameterDeclaration | VariableDeclaration | AccessorDeclaration
+>AccessorDeclaration : AccessorDeclaration
+>VariableOrParameterDeclaration : ParameterDeclaration | VariableDeclaration
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+
+        writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;

+>writeReturnTypeOfSignatureDeclaration : (signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
+>signatureDeclaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+>enclosingDeclaration : Node
+>Node : Node
+>flags : TypeFormatFlags
+>TypeFormatFlags : TypeFormatFlags
+>writer : SymbolWriter
+>SymbolWriter : SymbolWriter
+
+        isSymbolAccessible(symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags): SymbolAccessiblityResult;

+>isSymbolAccessible : (symbol: Symbol, enclosingDeclaration: Node, meaning: SymbolFlags) => SymbolAccessiblityResult
+>symbol : Symbol
+>Symbol : Symbol
+>enclosingDeclaration : Node
+>Node : Node
+>meaning : SymbolFlags
+>SymbolFlags : SymbolFlags
+>SymbolAccessiblityResult : SymbolAccessiblityResult
+
+        isEntityNameVisible(entityName: EntityName, enclosingDeclaration: Node): SymbolVisibilityResult;

+>isEntityNameVisible : (entityName: Identifier | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
+>entityName : Identifier | QualifiedName
+>EntityName : Identifier | QualifiedName
+>enclosingDeclaration : Node
+>Node : Node
+>SymbolVisibilityResult : SymbolVisibilityResult
+
+        getConstantValue(node: PropertyAccessExpression | ElementAccessExpression): number;

+>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression) => number
+>node : PropertyAccessExpression | ElementAccessExpression
+>PropertyAccessExpression : PropertyAccessExpression
+>ElementAccessExpression : ElementAccessExpression
+
+        isEmitBlocked(sourceFile?: SourceFile): boolean;

+>isEmitBlocked : (sourceFile?: SourceFile) => boolean
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+    }

+    const enum SymbolFlags {

+>SymbolFlags : SymbolFlags
+
+        FunctionScopedVariable = 1,

+>FunctionScopedVariable : SymbolFlags
+
+        BlockScopedVariable = 2,

+>BlockScopedVariable : SymbolFlags
+
+        Property = 4,

+>Property : SymbolFlags
+
+        EnumMember = 8,

+>EnumMember : SymbolFlags
+
+        Function = 16,

+>Function : SymbolFlags
+
+        Class = 32,

+>Class : SymbolFlags
+
+        Interface = 64,

+>Interface : SymbolFlags
+
+        ConstEnum = 128,

+>ConstEnum : SymbolFlags
+
+        RegularEnum = 256,

+>RegularEnum : SymbolFlags
+
+        ValueModule = 512,

+>ValueModule : SymbolFlags
+
+        NamespaceModule = 1024,

+>NamespaceModule : SymbolFlags
+
+        TypeLiteral = 2048,

+>TypeLiteral : SymbolFlags
+
+        ObjectLiteral = 4096,

+>ObjectLiteral : SymbolFlags
+
+        Method = 8192,

+>Method : SymbolFlags
+
+        Constructor = 16384,

+>Constructor : SymbolFlags
+
+        GetAccessor = 32768,

+>GetAccessor : SymbolFlags
+
+        SetAccessor = 65536,

+>SetAccessor : SymbolFlags
+
+        CallSignature = 131072,

+>CallSignature : SymbolFlags
+
+        ConstructSignature = 262144,

+>ConstructSignature : SymbolFlags
+
+        IndexSignature = 524288,

+>IndexSignature : SymbolFlags
+
+        TypeParameter = 1048576,

+>TypeParameter : SymbolFlags
+
+        TypeAlias = 2097152,

+>TypeAlias : SymbolFlags
+
+        ExportValue = 4194304,

+>ExportValue : SymbolFlags
+
+        ExportType = 8388608,

+>ExportType : SymbolFlags
+
+        ExportNamespace = 16777216,

+>ExportNamespace : SymbolFlags
+
+        Import = 33554432,

+>Import : SymbolFlags
+
+        Instantiated = 67108864,

+>Instantiated : SymbolFlags
+
+        Merged = 134217728,

+>Merged : SymbolFlags
+
+        Transient = 268435456,

+>Transient : SymbolFlags
+
+        Prototype = 536870912,

+>Prototype : SymbolFlags
+
+        UnionProperty = 1073741824,

+>UnionProperty : SymbolFlags
+
+        Enum = 384,

+>Enum : SymbolFlags
+
+        Variable = 3,

+>Variable : SymbolFlags
+
+        Value = 107455,

+>Value : SymbolFlags
+
+        Type = 3152352,

+>Type : SymbolFlags
+
+        Namespace = 1536,

+>Namespace : SymbolFlags
+
+        Module = 1536,

+>Module : SymbolFlags
+
+        Accessor = 98304,

+>Accessor : SymbolFlags
+
+        Signature = 917504,

+>Signature : SymbolFlags
+
+        FunctionScopedVariableExcludes = 107454,

+>FunctionScopedVariableExcludes : SymbolFlags
+
+        BlockScopedVariableExcludes = 107455,

+>BlockScopedVariableExcludes : SymbolFlags
+
+        ParameterExcludes = 107455,

+>ParameterExcludes : SymbolFlags
+
+        PropertyExcludes = 107455,

+>PropertyExcludes : SymbolFlags
+
+        EnumMemberExcludes = 107455,

+>EnumMemberExcludes : SymbolFlags
+
+        FunctionExcludes = 106927,

+>FunctionExcludes : SymbolFlags
+
+        ClassExcludes = 3258879,

+>ClassExcludes : SymbolFlags
+
+        InterfaceExcludes = 3152288,

+>InterfaceExcludes : SymbolFlags
+
+        RegularEnumExcludes = 3258623,

+>RegularEnumExcludes : SymbolFlags
+
+        ConstEnumExcludes = 3259263,

+>ConstEnumExcludes : SymbolFlags
+
+        ValueModuleExcludes = 106639,

+>ValueModuleExcludes : SymbolFlags
+
+        NamespaceModuleExcludes = 0,

+>NamespaceModuleExcludes : SymbolFlags
+
+        MethodExcludes = 99263,

+>MethodExcludes : SymbolFlags
+
+        GetAccessorExcludes = 41919,

+>GetAccessorExcludes : SymbolFlags
+
+        SetAccessorExcludes = 74687,

+>SetAccessorExcludes : SymbolFlags
+
+        TypeParameterExcludes = 2103776,

+>TypeParameterExcludes : SymbolFlags
+
+        TypeAliasExcludes = 3152352,

+>TypeAliasExcludes : SymbolFlags
+
+        ImportExcludes = 33554432,

+>ImportExcludes : SymbolFlags
+
+        ModuleMember = 35653619,

+>ModuleMember : SymbolFlags
+
+        ExportHasLocal = 944,

+>ExportHasLocal : SymbolFlags
+
+        HasLocals = 1041936,

+>HasLocals : SymbolFlags
+
+        HasExports = 1952,

+>HasExports : SymbolFlags
+
+        HasMembers = 6240,

+>HasMembers : SymbolFlags
+
+        IsContainer = 1048560,

+>IsContainer : SymbolFlags
+
+        PropertyOrAccessor = 98308,

+>PropertyOrAccessor : SymbolFlags
+
+        Export = 29360128,

+>Export : SymbolFlags
+    }

+    interface Symbol {

+>Symbol : Symbol
+
+        flags: SymbolFlags;

+>flags : SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        name: string;

+>name : string
+
+        id?: number;

+>id : number
+
+        mergeId?: number;

+>mergeId : number
+
+        declarations?: Declaration[];

+>declarations : Declaration[]
+>Declaration : Declaration
+
+        parent?: Symbol;

+>parent : Symbol
+>Symbol : Symbol
+
+        members?: SymbolTable;

+>members : SymbolTable
+>SymbolTable : SymbolTable
+
+        exports?: SymbolTable;

+>exports : SymbolTable
+>SymbolTable : SymbolTable
+
+        exportSymbol?: Symbol;

+>exportSymbol : Symbol
+>Symbol : Symbol
+
+        valueDeclaration?: Declaration;

+>valueDeclaration : Declaration
+>Declaration : Declaration
+
+        constEnumOnlyModule?: boolean;

+>constEnumOnlyModule : boolean
+    }

+    interface SymbolLinks {

+>SymbolLinks : SymbolLinks
+
+        target?: Symbol;

+>target : Symbol
+>Symbol : Symbol
+
+        type?: Type;

+>type : Type
+>Type : Type
+
+        declaredType?: Type;

+>declaredType : Type
+>Type : Type
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+
+        referenced?: boolean;

+>referenced : boolean
+
+        exportAssignSymbol?: Symbol;

+>exportAssignSymbol : Symbol
+>Symbol : Symbol
+
+        unionType?: UnionType;

+>unionType : UnionType
+>UnionType : UnionType
+    }

+    interface TransientSymbol extends Symbol, SymbolLinks {

+>TransientSymbol : TransientSymbol
+>Symbol : Symbol
+>SymbolLinks : SymbolLinks
+    }

+    interface SymbolTable {

+>SymbolTable : SymbolTable
+
+        [index: string]: Symbol;

+>index : string
+>Symbol : Symbol
+    }

+    const enum NodeCheckFlags {

+>NodeCheckFlags : NodeCheckFlags
+
+        TypeChecked = 1,

+>TypeChecked : NodeCheckFlags
+
+        LexicalThis = 2,

+>LexicalThis : NodeCheckFlags
+
+        CaptureThis = 4,

+>CaptureThis : NodeCheckFlags
+
+        EmitExtends = 8,

+>EmitExtends : NodeCheckFlags
+
+        SuperInstance = 16,

+>SuperInstance : NodeCheckFlags
+
+        SuperStatic = 32,

+>SuperStatic : NodeCheckFlags
+
+        ContextChecked = 64,

+>ContextChecked : NodeCheckFlags
+
+        EnumValuesComputed = 128,

+>EnumValuesComputed : NodeCheckFlags
+    }

+    interface NodeLinks {

+>NodeLinks : NodeLinks
+
+        resolvedType?: Type;

+>resolvedType : Type
+>Type : Type
+
+        resolvedSignature?: Signature;

+>resolvedSignature : Signature
+>Signature : Signature
+
+        resolvedSymbol?: Symbol;

+>resolvedSymbol : Symbol
+>Symbol : Symbol
+
+        flags?: NodeCheckFlags;

+>flags : NodeCheckFlags
+>NodeCheckFlags : NodeCheckFlags
+
+        enumMemberValue?: number;

+>enumMemberValue : number
+
+        isIllegalTypeReferenceInConstraint?: boolean;

+>isIllegalTypeReferenceInConstraint : boolean
+
+        isVisible?: boolean;

+>isVisible : boolean
+
+        localModuleName?: string;

+>localModuleName : string
+
+        assignmentChecks?: Map<boolean>;

+>assignmentChecks : Map<boolean>
+>Map : Map<T>
+    }

+    const enum TypeFlags {

+>TypeFlags : TypeFlags
+
+        Any = 1,

+>Any : TypeFlags
+
+        String = 2,

+>String : TypeFlags
+
+        Number = 4,

+>Number : TypeFlags
+
+        Boolean = 8,

+>Boolean : TypeFlags
+
+        Void = 16,

+>Void : TypeFlags
+
+        Undefined = 32,

+>Undefined : TypeFlags
+
+        Null = 64,

+>Null : TypeFlags
+
+        Enum = 128,

+>Enum : TypeFlags
+
+        StringLiteral = 256,

+>StringLiteral : TypeFlags
+
+        TypeParameter = 512,

+>TypeParameter : TypeFlags
+
+        Class = 1024,

+>Class : TypeFlags
+
+        Interface = 2048,

+>Interface : TypeFlags
+
+        Reference = 4096,

+>Reference : TypeFlags
+
+        Tuple = 8192,

+>Tuple : TypeFlags
+
+        Union = 16384,

+>Union : TypeFlags
+
+        Anonymous = 32768,

+>Anonymous : TypeFlags
+
+        FromSignature = 65536,

+>FromSignature : TypeFlags
+
+        Intrinsic = 127,

+>Intrinsic : TypeFlags
+
+        StringLike = 258,

+>StringLike : TypeFlags
+
+        NumberLike = 132,

+>NumberLike : TypeFlags
+
+        ObjectType = 48128,

+>ObjectType : TypeFlags
+    }

+    interface Type {

+>Type : Type
+
+        flags: TypeFlags;

+>flags : TypeFlags
+>TypeFlags : TypeFlags
+
+        id: number;

+>id : number
+
+        symbol?: Symbol;

+>symbol : Symbol
+>Symbol : Symbol
+    }

+    interface IntrinsicType extends Type {

+>IntrinsicType : IntrinsicType
+>Type : Type
+
+        intrinsicName: string;

+>intrinsicName : string
+    }

+    interface StringLiteralType extends Type {

+>StringLiteralType : StringLiteralType
+>Type : Type
+
+        text: string;

+>text : string
+    }

+    interface ObjectType extends Type {

+>ObjectType : ObjectType
+>Type : Type
+    }

+    interface InterfaceType extends ObjectType {

+>InterfaceType : InterfaceType
+>ObjectType : ObjectType
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        baseTypes: ObjectType[];

+>baseTypes : ObjectType[]
+>ObjectType : ObjectType
+
+        declaredProperties: Symbol[];

+>declaredProperties : Symbol[]
+>Symbol : Symbol
+
+        declaredCallSignatures: Signature[];

+>declaredCallSignatures : Signature[]
+>Signature : Signature
+
+        declaredConstructSignatures: Signature[];

+>declaredConstructSignatures : Signature[]
+>Signature : Signature
+
+        declaredStringIndexType: Type;

+>declaredStringIndexType : Type
+>Type : Type
+
+        declaredNumberIndexType: Type;

+>declaredNumberIndexType : Type
+>Type : Type
+    }

+    interface TypeReference extends ObjectType {

+>TypeReference : TypeReference
+>ObjectType : ObjectType
+
+        target: GenericType;

+>target : GenericType
+>GenericType : GenericType
+
+        typeArguments: Type[];

+>typeArguments : Type[]
+>Type : Type
+    }

+    interface GenericType extends InterfaceType, TypeReference {

+>GenericType : GenericType
+>InterfaceType : InterfaceType
+>TypeReference : TypeReference
+
+        instantiations: Map<TypeReference>;

+>instantiations : Map<TypeReference>
+>Map : Map<T>
+>TypeReference : TypeReference
+
+        openReferenceTargets: GenericType[];

+>openReferenceTargets : GenericType[]
+>GenericType : GenericType
+
+        openReferenceChecks: Map<boolean>;

+>openReferenceChecks : Map<boolean>
+>Map : Map<T>
+    }

+    interface TupleType extends ObjectType {

+>TupleType : TupleType
+>ObjectType : ObjectType
+
+        elementTypes: Type[];

+>elementTypes : Type[]
+>Type : Type
+
+        baseArrayType: TypeReference;

+>baseArrayType : TypeReference
+>TypeReference : TypeReference
+    }

+    interface UnionType extends Type {

+>UnionType : UnionType
+>Type : Type
+
+        types: Type[];

+>types : Type[]
+>Type : Type
+
+        resolvedProperties: SymbolTable;

+>resolvedProperties : SymbolTable
+>SymbolTable : SymbolTable
+    }

+    interface ResolvedType extends ObjectType, UnionType {

+>ResolvedType : ResolvedType
+>ObjectType : ObjectType
+>UnionType : UnionType
+
+        members: SymbolTable;

+>members : SymbolTable
+>SymbolTable : SymbolTable
+
+        properties: Symbol[];

+>properties : Symbol[]
+>Symbol : Symbol
+
+        callSignatures: Signature[];

+>callSignatures : Signature[]
+>Signature : Signature
+
+        constructSignatures: Signature[];

+>constructSignatures : Signature[]
+>Signature : Signature
+
+        stringIndexType: Type;

+>stringIndexType : Type
+>Type : Type
+
+        numberIndexType: Type;

+>numberIndexType : Type
+>Type : Type
+    }

+    interface TypeParameter extends Type {

+>TypeParameter : TypeParameter
+>Type : Type
+
+        constraint: Type;

+>constraint : Type
+>Type : Type
+
+        target?: TypeParameter;

+>target : TypeParameter
+>TypeParameter : TypeParameter
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+    }

+    const enum SignatureKind {

+>SignatureKind : SignatureKind
+
+        Call = 0,

+>Call : SignatureKind
+
+        Construct = 1,

+>Construct : SignatureKind
+    }

+    interface Signature {

+>Signature : Signature
+
+        declaration: SignatureDeclaration;

+>declaration : SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        parameters: Symbol[];

+>parameters : Symbol[]
+>Symbol : Symbol
+
+        resolvedReturnType: Type;

+>resolvedReturnType : Type
+>Type : Type
+
+        minArgumentCount: number;

+>minArgumentCount : number
+
+        hasRestParameter: boolean;

+>hasRestParameter : boolean
+
+        hasStringLiterals: boolean;

+>hasStringLiterals : boolean
+
+        target?: Signature;

+>target : Signature
+>Signature : Signature
+
+        mapper?: TypeMapper;

+>mapper : TypeMapper
+>TypeMapper : TypeMapper
+
+        unionSignatures?: Signature[];

+>unionSignatures : Signature[]
+>Signature : Signature
+
+        erasedSignatureCache?: Signature;

+>erasedSignatureCache : Signature
+>Signature : Signature
+
+        isolatedSignatureType?: ObjectType;

+>isolatedSignatureType : ObjectType
+>ObjectType : ObjectType
+    }

+    const enum IndexKind {

+>IndexKind : IndexKind
+
+        String = 0,

+>String : IndexKind
+
+        Number = 1,

+>Number : IndexKind
+    }

+    interface TypeMapper {

+>TypeMapper : TypeMapper
+
+        (t: Type): Type;

+>t : Type
+>Type : Type
+>Type : Type
+    }

+    interface TypeInferences {

+>TypeInferences : TypeInferences
+
+        primary: Type[];

+>primary : Type[]
+>Type : Type
+
+        secondary: Type[];

+>secondary : Type[]
+>Type : Type
+    }

+    interface InferenceContext {

+>InferenceContext : InferenceContext
+
+        typeParameters: TypeParameter[];

+>typeParameters : TypeParameter[]
+>TypeParameter : TypeParameter
+
+        inferUnionTypes: boolean;

+>inferUnionTypes : boolean
+
+        inferences: TypeInferences[];

+>inferences : TypeInferences[]
+>TypeInferences : TypeInferences
+
+        inferredTypes: Type[];

+>inferredTypes : Type[]
+>Type : Type
+
+        failedTypeParameterIndex?: number;

+>failedTypeParameterIndex : number
+    }

+    interface DiagnosticMessage {

+>DiagnosticMessage : DiagnosticMessage
+
+        key: string;

+>key : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        isEarly?: boolean;

+>isEarly : boolean
+    }

+    interface DiagnosticMessageChain {

+>DiagnosticMessageChain : DiagnosticMessageChain
+
+        messageText: string;

+>messageText : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        next?: DiagnosticMessageChain;

+>next : DiagnosticMessageChain
+>DiagnosticMessageChain : DiagnosticMessageChain
+    }

+    interface Diagnostic {

+>Diagnostic : Diagnostic
+
+        file: SourceFile;

+>file : SourceFile
+>SourceFile : SourceFile
+
+        start: number;

+>start : number
+
+        length: number;

+>length : number
+
+        messageText: string;

+>messageText : string
+
+        category: DiagnosticCategory;

+>category : DiagnosticCategory
+>DiagnosticCategory : DiagnosticCategory
+
+        code: number;

+>code : number
+
+        /**

+          * Early error - any error (can be produced at parsing\binding\typechecking step) that blocks emit

+          */

+        isEarly?: boolean;

+>isEarly : boolean
+    }

+    enum DiagnosticCategory {

+>DiagnosticCategory : DiagnosticCategory
+
+        Warning = 0,

+>Warning : DiagnosticCategory
+
+        Error = 1,

+>Error : DiagnosticCategory
+
+        Message = 2,

+>Message : DiagnosticCategory
+    }

+    interface CompilerOptions {

+>CompilerOptions : CompilerOptions
+
+        allowNonTsExtensions?: boolean;

+>allowNonTsExtensions : boolean
+
+        charset?: string;

+>charset : string
+
+        codepage?: number;

+>codepage : number
+
+        declaration?: boolean;

+>declaration : boolean
+
+        diagnostics?: boolean;

+>diagnostics : boolean
+
+        emitBOM?: boolean;

+>emitBOM : boolean
+
+        help?: boolean;

+>help : boolean
+
+        locale?: string;

+>locale : string
+
+        mapRoot?: string;

+>mapRoot : string
+
+        module?: ModuleKind;

+>module : ModuleKind
+>ModuleKind : ModuleKind
+
+        noEmitOnError?: boolean;

+>noEmitOnError : boolean
+
+        noErrorTruncation?: boolean;

+>noErrorTruncation : boolean
+
+        noImplicitAny?: boolean;

+>noImplicitAny : boolean
+
+        noLib?: boolean;

+>noLib : boolean
+
+        noLibCheck?: boolean;

+>noLibCheck : boolean
+
+        noResolve?: boolean;

+>noResolve : boolean
+
+        out?: string;

+>out : string
+
+        outDir?: string;

+>outDir : string
+
+        preserveConstEnums?: boolean;

+>preserveConstEnums : boolean
+
+        removeComments?: boolean;

+>removeComments : boolean
+
+        sourceMap?: boolean;

+>sourceMap : boolean
+
+        sourceRoot?: string;

+>sourceRoot : string
+
+        suppressImplicitAnyIndexErrors?: boolean;

+>suppressImplicitAnyIndexErrors : boolean
+
+        target?: ScriptTarget;

+>target : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+        version?: boolean;

+>version : boolean
+
+        watch?: boolean;

+>watch : boolean
+
+        [option: string]: string | number | boolean;

+>option : string
+    }

+    const enum ModuleKind {

+>ModuleKind : ModuleKind
+
+        None = 0,

+>None : ModuleKind
+
+        CommonJS = 1,

+>CommonJS : ModuleKind
+
+        AMD = 2,

+>AMD : ModuleKind
+    }

+    interface LineAndCharacter {

+>LineAndCharacter : LineAndCharacter
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+    }

+    const enum ScriptTarget {

+>ScriptTarget : ScriptTarget
+
+        ES3 = 0,

+>ES3 : ScriptTarget
+
+        ES5 = 1,

+>ES5 : ScriptTarget
+
+        ES6 = 2,

+>ES6 : ScriptTarget
+
+        Latest = 2,

+>Latest : ScriptTarget
+    }

+    interface ParsedCommandLine {

+>ParsedCommandLine : ParsedCommandLine
+
+        options: CompilerOptions;

+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        filenames: string[];

+>filenames : string[]
+
+        errors: Diagnostic[];

+>errors : Diagnostic[]
+>Diagnostic : Diagnostic
+    }

+    interface CommandLineOption {

+>CommandLineOption : CommandLineOption
+
+        name: string;

+>name : string
+
+        type: string | Map<number>;

+>type : string | Map<number>
+>Map : Map<T>
+
+        shortName?: string;

+>shortName : string
+
+        description?: DiagnosticMessage;

+>description : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+
+        paramType?: DiagnosticMessage;

+>paramType : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+
+        error?: DiagnosticMessage;

+>error : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+    }

+    const enum CharacterCodes {

+>CharacterCodes : CharacterCodes
+
+        nullCharacter = 0,

+>nullCharacter : CharacterCodes
+
+        maxAsciiCharacter = 127,

+>maxAsciiCharacter : CharacterCodes
+
+        lineFeed = 10,

+>lineFeed : CharacterCodes
+
+        carriageReturn = 13,

+>carriageReturn : CharacterCodes
+
+        lineSeparator = 8232,

+>lineSeparator : CharacterCodes
+
+        paragraphSeparator = 8233,

+>paragraphSeparator : CharacterCodes
+
+        nextLine = 133,

+>nextLine : CharacterCodes
+
+        space = 32,

+>space : CharacterCodes
+
+        nonBreakingSpace = 160,

+>nonBreakingSpace : CharacterCodes
+
+        enQuad = 8192,

+>enQuad : CharacterCodes
+
+        emQuad = 8193,

+>emQuad : CharacterCodes
+
+        enSpace = 8194,

+>enSpace : CharacterCodes
+
+        emSpace = 8195,

+>emSpace : CharacterCodes
+
+        threePerEmSpace = 8196,

+>threePerEmSpace : CharacterCodes
+
+        fourPerEmSpace = 8197,

+>fourPerEmSpace : CharacterCodes
+
+        sixPerEmSpace = 8198,

+>sixPerEmSpace : CharacterCodes
+
+        figureSpace = 8199,

+>figureSpace : CharacterCodes
+
+        punctuationSpace = 8200,

+>punctuationSpace : CharacterCodes
+
+        thinSpace = 8201,

+>thinSpace : CharacterCodes
+
+        hairSpace = 8202,

+>hairSpace : CharacterCodes
+
+        zeroWidthSpace = 8203,

+>zeroWidthSpace : CharacterCodes
+
+        narrowNoBreakSpace = 8239,

+>narrowNoBreakSpace : CharacterCodes
+
+        ideographicSpace = 12288,

+>ideographicSpace : CharacterCodes
+
+        mathematicalSpace = 8287,

+>mathematicalSpace : CharacterCodes
+
+        ogham = 5760,

+>ogham : CharacterCodes
+
+        _ = 95,

+>_ : CharacterCodes
+
+        $ = 36,

+>$ : CharacterCodes
+
+        _0 = 48,

+>_0 : CharacterCodes
+
+        _1 = 49,

+>_1 : CharacterCodes
+
+        _2 = 50,

+>_2 : CharacterCodes
+
+        _3 = 51,

+>_3 : CharacterCodes
+
+        _4 = 52,

+>_4 : CharacterCodes
+
+        _5 = 53,

+>_5 : CharacterCodes
+
+        _6 = 54,

+>_6 : CharacterCodes
+
+        _7 = 55,

+>_7 : CharacterCodes
+
+        _8 = 56,

+>_8 : CharacterCodes
+
+        _9 = 57,

+>_9 : CharacterCodes
+
+        a = 97,

+>a : CharacterCodes
+
+        b = 98,

+>b : CharacterCodes
+
+        c = 99,

+>c : CharacterCodes
+
+        d = 100,

+>d : CharacterCodes
+
+        e = 101,

+>e : CharacterCodes
+
+        f = 102,

+>f : CharacterCodes
+
+        g = 103,

+>g : CharacterCodes
+
+        h = 104,

+>h : CharacterCodes
+
+        i = 105,

+>i : CharacterCodes
+
+        j = 106,

+>j : CharacterCodes
+
+        k = 107,

+>k : CharacterCodes
+
+        l = 108,

+>l : CharacterCodes
+
+        m = 109,

+>m : CharacterCodes
+
+        n = 110,

+>n : CharacterCodes
+
+        o = 111,

+>o : CharacterCodes
+
+        p = 112,

+>p : CharacterCodes
+
+        q = 113,

+>q : CharacterCodes
+
+        r = 114,

+>r : CharacterCodes
+
+        s = 115,

+>s : CharacterCodes
+
+        t = 116,

+>t : CharacterCodes
+
+        u = 117,

+>u : CharacterCodes
+
+        v = 118,

+>v : CharacterCodes
+
+        w = 119,

+>w : CharacterCodes
+
+        x = 120,

+>x : CharacterCodes
+
+        y = 121,

+>y : CharacterCodes
+
+        z = 122,

+>z : CharacterCodes
+
+        A = 65,

+>A : CharacterCodes
+
+        B = 66,

+>B : CharacterCodes
+
+        C = 67,

+>C : CharacterCodes
+
+        D = 68,

+>D : CharacterCodes
+
+        E = 69,

+>E : CharacterCodes
+
+        F = 70,

+>F : CharacterCodes
+
+        G = 71,

+>G : CharacterCodes
+
+        H = 72,

+>H : CharacterCodes
+
+        I = 73,

+>I : CharacterCodes
+
+        J = 74,

+>J : CharacterCodes
+
+        K = 75,

+>K : CharacterCodes
+
+        L = 76,

+>L : CharacterCodes
+
+        M = 77,

+>M : CharacterCodes
+
+        N = 78,

+>N : CharacterCodes
+
+        O = 79,

+>O : CharacterCodes
+
+        P = 80,

+>P : CharacterCodes
+
+        Q = 81,

+>Q : CharacterCodes
+
+        R = 82,

+>R : CharacterCodes
+
+        S = 83,

+>S : CharacterCodes
+
+        T = 84,

+>T : CharacterCodes
+
+        U = 85,

+>U : CharacterCodes
+
+        V = 86,

+>V : CharacterCodes
+
+        W = 87,

+>W : CharacterCodes
+
+        X = 88,

+>X : CharacterCodes
+
+        Y = 89,

+>Y : CharacterCodes
+
+        Z = 90,

+>Z : CharacterCodes
+
+        ampersand = 38,

+>ampersand : CharacterCodes
+
+        asterisk = 42,

+>asterisk : CharacterCodes
+
+        at = 64,

+>at : CharacterCodes
+
+        backslash = 92,

+>backslash : CharacterCodes
+
+        backtick = 96,

+>backtick : CharacterCodes
+
+        bar = 124,

+>bar : CharacterCodes
+
+        caret = 94,

+>caret : CharacterCodes
+
+        closeBrace = 125,

+>closeBrace : CharacterCodes
+
+        closeBracket = 93,

+>closeBracket : CharacterCodes
+
+        closeParen = 41,

+>closeParen : CharacterCodes
+
+        colon = 58,

+>colon : CharacterCodes
+
+        comma = 44,

+>comma : CharacterCodes
+
+        dot = 46,

+>dot : CharacterCodes
+
+        doubleQuote = 34,

+>doubleQuote : CharacterCodes
+
+        equals = 61,

+>equals : CharacterCodes
+
+        exclamation = 33,

+>exclamation : CharacterCodes
+
+        greaterThan = 62,

+>greaterThan : CharacterCodes
+
+        lessThan = 60,

+>lessThan : CharacterCodes
+
+        minus = 45,

+>minus : CharacterCodes
+
+        openBrace = 123,

+>openBrace : CharacterCodes
+
+        openBracket = 91,

+>openBracket : CharacterCodes
+
+        openParen = 40,

+>openParen : CharacterCodes
+
+        percent = 37,

+>percent : CharacterCodes
+
+        plus = 43,

+>plus : CharacterCodes
+
+        question = 63,

+>question : CharacterCodes
+
+        semicolon = 59,

+>semicolon : CharacterCodes
+
+        singleQuote = 39,

+>singleQuote : CharacterCodes
+
+        slash = 47,

+>slash : CharacterCodes
+
+        tilde = 126,

+>tilde : CharacterCodes
+
+        backspace = 8,

+>backspace : CharacterCodes
+
+        formFeed = 12,

+>formFeed : CharacterCodes
+
+        byteOrderMark = 65279,

+>byteOrderMark : CharacterCodes
+
+        tab = 9,

+>tab : CharacterCodes
+
+        verticalTab = 11,

+>verticalTab : CharacterCodes
+    }

+    interface CancellationToken {

+>CancellationToken : CancellationToken
+
+        isCancellationRequested(): boolean;

+>isCancellationRequested : () => boolean
+    }

+    interface CompilerHost {

+>CompilerHost : CompilerHost
+
+        getSourceFile(filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;

+>getSourceFile : (filename: string, languageVersion: ScriptTarget, onError?: (message: string) => void) => SourceFile
+>filename : string
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>onError : (message: string) => void
+>message : string
+>SourceFile : SourceFile
+
+        getDefaultLibFilename(options: CompilerOptions): string;

+>getDefaultLibFilename : (options: CompilerOptions) => string
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getCancellationToken?(): CancellationToken;

+>getCancellationToken : () => CancellationToken
+>CancellationToken : CancellationToken
+
+        writeFile(filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void;

+>writeFile : (filename: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void) => void
+>filename : string
+>data : string
+>writeByteOrderMark : boolean
+>onError : (message: string) => void
+>message : string
+
+        getCurrentDirectory(): string;

+>getCurrentDirectory : () => string
+
+        getCanonicalFileName(fileName: string): string;

+>getCanonicalFileName : (fileName: string) => string
+>fileName : string
+
+        useCaseSensitiveFileNames(): boolean;

+>useCaseSensitiveFileNames : () => boolean
+
+        getNewLine(): string;

+>getNewLine : () => string
+    }

+}

+declare module ts {

+>ts : typeof ts
+
+    interface ErrorCallback {

+>ErrorCallback : ErrorCallback
+
+        (message: DiagnosticMessage): void;

+>message : DiagnosticMessage
+>DiagnosticMessage : DiagnosticMessage
+    }

+    interface CommentCallback {

+>CommentCallback : CommentCallback
+
+        (pos: number, end: number): void;

+>pos : number
+>end : number
+    }

+    interface Scanner {

+>Scanner : Scanner
+
+        getStartPos(): number;

+>getStartPos : () => number
+
+        getToken(): SyntaxKind;

+>getToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        getTextPos(): number;

+>getTextPos : () => number
+
+        getTokenPos(): number;

+>getTokenPos : () => number
+
+        getTokenText(): string;

+>getTokenText : () => string
+
+        getTokenValue(): string;

+>getTokenValue : () => string
+
+        hasPrecedingLineBreak(): boolean;

+>hasPrecedingLineBreak : () => boolean
+
+        isIdentifier(): boolean;

+>isIdentifier : () => boolean
+
+        isReservedWord(): boolean;

+>isReservedWord : () => boolean
+
+        isUnterminated(): boolean;

+>isUnterminated : () => boolean
+
+        reScanGreaterToken(): SyntaxKind;

+>reScanGreaterToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        reScanSlashToken(): SyntaxKind;

+>reScanSlashToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        reScanTemplateToken(): SyntaxKind;

+>reScanTemplateToken : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        scan(): SyntaxKind;

+>scan : () => SyntaxKind
+>SyntaxKind : SyntaxKind
+
+        setText(text: string): void;

+>setText : (text: string) => void
+>text : string
+
+        setTextPos(textPos: number): void;

+>setTextPos : (textPos: number) => void
+>textPos : number
+
+        lookAhead<T>(callback: () => T): T;

+>lookAhead : <T>(callback: () => T) => T
+>T : T
+>callback : () => T
+>T : T
+>T : T
+
+        tryScan<T>(callback: () => T): T;

+>tryScan : <T>(callback: () => T) => T
+>T : T
+>callback : () => T
+>T : T
+>T : T
+    }

+    function tokenToString(t: SyntaxKind): string;

+>tokenToString : (t: SyntaxKind) => string
+>t : SyntaxKind
+>SyntaxKind : SyntaxKind
+
+    function computeLineStarts(text: string): number[];

+>computeLineStarts : (text: string) => number[]
+>text : string
+
+    function getPositionFromLineAndCharacter(lineStarts: number[], line: number, character: number): number;

+>getPositionFromLineAndCharacter : (lineStarts: number[], line: number, character: number) => number
+>lineStarts : number[]
+>line : number
+>character : number
+
+    function getLineAndCharacterOfPosition(lineStarts: number[], position: number): {

+>getLineAndCharacterOfPosition : (lineStarts: number[], position: number) => { line: number; character: number; }
+>lineStarts : number[]
+>position : number
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+
+    };

+    function positionToLineAndCharacter(text: string, pos: number): {

+>positionToLineAndCharacter : (text: string, pos: number) => { line: number; character: number; }
+>text : string
+>pos : number
+
+        line: number;

+>line : number
+
+        character: number;

+>character : number
+
+    };

+    function isWhiteSpace(ch: number): boolean;

+>isWhiteSpace : (ch: number) => boolean
+>ch : number
+
+    function isLineBreak(ch: number): boolean;

+>isLineBreak : (ch: number) => boolean
+>ch : number
+
+    function isOctalDigit(ch: number): boolean;

+>isOctalDigit : (ch: number) => boolean
+>ch : number
+
+    function skipTrivia(text: string, pos: number, stopAfterLineBreak?: boolean): number;

+>skipTrivia : (text: string, pos: number, stopAfterLineBreak?: boolean) => number
+>text : string
+>pos : number
+>stopAfterLineBreak : boolean
+
+    function getLeadingCommentRanges(text: string, pos: number): CommentRange[];

+>getLeadingCommentRanges : (text: string, pos: number) => CommentRange[]
+>text : string
+>pos : number
+>CommentRange : CommentRange
+
+    function getTrailingCommentRanges(text: string, pos: number): CommentRange[];

+>getTrailingCommentRanges : (text: string, pos: number) => CommentRange[]
+>text : string
+>pos : number
+>CommentRange : CommentRange
+
+    function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;

+>isIdentifierStart : (ch: number, languageVersion: ScriptTarget) => boolean
+>ch : number
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+    function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;

+>isIdentifierPart : (ch: number, languageVersion: ScriptTarget) => boolean
+>ch : number
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+
+    function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback): Scanner;

+>createScanner : (languageVersion: ScriptTarget, skipTrivia: boolean, text?: string, onError?: ErrorCallback) => Scanner
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>skipTrivia : boolean
+>text : string
+>onError : ErrorCallback
+>ErrorCallback : ErrorCallback
+>Scanner : Scanner
+}

+declare module ts {

+>ts : typeof ts
+
+    function getNodeConstructor(kind: SyntaxKind): new () => Node;

+>getNodeConstructor : (kind: SyntaxKind) => new () => Node
+>kind : SyntaxKind
+>SyntaxKind : SyntaxKind
+>Node : Node
+
+    function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T): T;

+>forEachChild : <T>(node: Node, cbNode: (node: Node) => T, cbNodes?: (nodes: Node[]) => T) => T
+>T : T
+>node : Node
+>Node : Node
+>cbNode : (node: Node) => T
+>node : Node
+>Node : Node
+>T : T
+>cbNodes : (nodes: Node[]) => T
+>nodes : Node[]
+>Node : Node
+>T : T
+>T : T
+
+    function createCompilerHost(options: CompilerOptions): CompilerHost;

+>createCompilerHost : (options: CompilerOptions) => CompilerHost
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+>CompilerHost : CompilerHost
+
+    function createSourceFile(filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean): SourceFile;

+>createSourceFile : (filename: string, sourceText: string, languageVersion: ScriptTarget, version: string, isOpen?: boolean) => SourceFile
+>filename : string
+>sourceText : string
+>languageVersion : ScriptTarget
+>ScriptTarget : ScriptTarget
+>version : string
+>isOpen : boolean
+>SourceFile : SourceFile
+
+    function createProgram(rootNames: string[], options: CompilerOptions, host: CompilerHost): Program;

+>createProgram : (rootNames: string[], options: CompilerOptions, host: CompilerHost) => Program
+>rootNames : string[]
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+>host : CompilerHost
+>CompilerHost : CompilerHost
+>Program : Program
+}

+declare module ts {

+>ts : typeof ts
+
+    function createTypeChecker(program: Program, fullTypeCheck: boolean): TypeChecker;

+>createTypeChecker : (program: Program, fullTypeCheck: boolean) => TypeChecker
+>program : Program
+>Program : Program
+>fullTypeCheck : boolean
+>TypeChecker : TypeChecker
+}

+declare module ts {

+>ts : typeof ts
+
+    var servicesVersion: string;

+>servicesVersion : string
+
+    interface Node {

+>Node : Node
+
+        getSourceFile(): SourceFile;

+>getSourceFile : () => SourceFile
+>SourceFile : SourceFile
+
+        getChildCount(sourceFile?: SourceFile): number;

+>getChildCount : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getChildAt(index: number, sourceFile?: SourceFile): Node;

+>getChildAt : (index: number, sourceFile?: SourceFile) => Node
+>index : number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getChildren(sourceFile?: SourceFile): Node[];

+>getChildren : (sourceFile?: SourceFile) => Node[]
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getStart(sourceFile?: SourceFile): number;

+>getStart : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullStart(): number;

+>getFullStart : () => number
+
+        getEnd(): number;

+>getEnd : () => number
+
+        getWidth(sourceFile?: SourceFile): number;

+>getWidth : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullWidth(): number;

+>getFullWidth : () => number
+
+        getLeadingTriviaWidth(sourceFile?: SourceFile): number;

+>getLeadingTriviaWidth : (sourceFile?: SourceFile) => number
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFullText(sourceFile?: SourceFile): string;

+>getFullText : (sourceFile?: SourceFile) => string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getText(sourceFile?: SourceFile): string;

+>getText : (sourceFile?: SourceFile) => string
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+
+        getFirstToken(sourceFile?: SourceFile): Node;

+>getFirstToken : (sourceFile?: SourceFile) => Node
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+
+        getLastToken(sourceFile?: SourceFile): Node;

+>getLastToken : (sourceFile?: SourceFile) => Node
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>Node : Node
+    }

+    interface Symbol {

+>Symbol : Symbol
+
+        getFlags(): SymbolFlags;

+>getFlags : () => SymbolFlags
+>SymbolFlags : SymbolFlags
+
+        getName(): string;

+>getName : () => string
+
+        getDeclarations(): Declaration[];

+>getDeclarations : () => Declaration[]
+>Declaration : Declaration
+
+        getDocumentationComment(): SymbolDisplayPart[];

+>getDocumentationComment : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface Type {

+>Type : Type
+
+        getFlags(): TypeFlags;

+>getFlags : () => TypeFlags
+>TypeFlags : TypeFlags
+
+        getSymbol(): Symbol;

+>getSymbol : () => Symbol
+>Symbol : Symbol
+
+        getProperties(): Symbol[];

+>getProperties : () => Symbol[]
+>Symbol : Symbol
+
+        getProperty(propertyName: string): Symbol;

+>getProperty : (propertyName: string) => Symbol
+>propertyName : string
+>Symbol : Symbol
+
+        getApparentProperties(): Symbol[];

+>getApparentProperties : () => Symbol[]
+>Symbol : Symbol
+
+        getCallSignatures(): Signature[];

+>getCallSignatures : () => Signature[]
+>Signature : Signature
+
+        getConstructSignatures(): Signature[];

+>getConstructSignatures : () => Signature[]
+>Signature : Signature
+
+        getStringIndexType(): Type;

+>getStringIndexType : () => Type
+>Type : Type
+
+        getNumberIndexType(): Type;

+>getNumberIndexType : () => Type
+>Type : Type
+    }

+    interface Signature {

+>Signature : Signature
+
+        getDeclaration(): SignatureDeclaration;

+>getDeclaration : () => SignatureDeclaration
+>SignatureDeclaration : SignatureDeclaration
+
+        getTypeParameters(): Type[];

+>getTypeParameters : () => Type[]
+>Type : Type
+
+        getParameters(): Symbol[];

+>getParameters : () => Symbol[]
+>Symbol : Symbol
+
+        getReturnType(): Type;

+>getReturnType : () => Type
+>Type : Type
+
+        getDocumentationComment(): SymbolDisplayPart[];

+>getDocumentationComment : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface SourceFile {

+>SourceFile : SourceFile
+
+        getScriptSnapshot(): IScriptSnapshot;

+>getScriptSnapshot : () => IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+
+        getNamedDeclarations(): Declaration[];

+>getNamedDeclarations : () => Declaration[]
+>Declaration : Declaration
+
+        update(scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;

+>update : (scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>textChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+>SourceFile : SourceFile
+    }

+    /**

+     * Represents an immutable snapshot of a script at a specified time.Once acquired, the

+     * snapshot is observably immutable. i.e. the same calls with the same parameters will return

+     * the same values.

+     */

+    interface IScriptSnapshot {

+>IScriptSnapshot : IScriptSnapshot
+
+        /** Gets a portion of the script snapshot specified by [start, end). */

+        getText(start: number, end: number): string;

+>getText : (start: number, end: number) => string
+>start : number
+>end : number
+
+        /** Gets the length of this script snapshot. */

+        getLength(): number;

+>getLength : () => number
+
+        /**

+         * This call returns the array containing the start position of every line.

+         * i.e."[0, 10, 55]".  TODO: consider making this optional.  The language service could

+         * always determine this (albeit in a more expensive manner).

+         */

+        getLineStartPositions(): number[];

+>getLineStartPositions : () => number[]
+
+        /**

+         * Gets the TextChangeRange that describe how the text changed between this text and

+         * an older version.  This information is used by the incremental parser to determine

+         * what sections of the script need to be re-parsed.  'undefined' can be returned if the

+         * change range cannot be determined.  However, in that case, incremental parsing will

+         * not happen and the entire document will be re - parsed.

+         */

+        getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange;

+>getChangeRange : (oldSnapshot: IScriptSnapshot) => TextChangeRange
+>oldSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>TextChangeRange : TextChangeRange
+    }

+    module ScriptSnapshot {

+>ScriptSnapshot : typeof ScriptSnapshot
+
+        function fromString(text: string): IScriptSnapshot;

+>fromString : (text: string) => IScriptSnapshot
+>text : string
+>IScriptSnapshot : IScriptSnapshot
+    }

+    interface PreProcessedFileInfo {

+>PreProcessedFileInfo : PreProcessedFileInfo
+
+        referencedFiles: FileReference[];

+>referencedFiles : FileReference[]
+>FileReference : FileReference
+
+        importedFiles: FileReference[];

+>importedFiles : FileReference[]
+>FileReference : FileReference
+
+        isLibFile: boolean;

+>isLibFile : boolean
+    }

+    interface Logger {

+>Logger : Logger
+
+        log(s: string): void;

+>log : (s: string) => void
+>s : string
+    }

+    interface LanguageServiceHost extends Logger {

+>LanguageServiceHost : LanguageServiceHost
+>Logger : Logger
+
+        getCompilationSettings(): CompilerOptions;

+>getCompilationSettings : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+        getScriptFileNames(): string[];

+>getScriptFileNames : () => string[]
+
+        getScriptVersion(fileName: string): string;

+>getScriptVersion : (fileName: string) => string
+>fileName : string
+
+        getScriptIsOpen(fileName: string): boolean;

+>getScriptIsOpen : (fileName: string) => boolean
+>fileName : string
+
+        getScriptSnapshot(fileName: string): IScriptSnapshot;

+>getScriptSnapshot : (fileName: string) => IScriptSnapshot
+>fileName : string
+>IScriptSnapshot : IScriptSnapshot
+
+        getLocalizedDiagnosticMessages?(): any;

+>getLocalizedDiagnosticMessages : () => any
+
+        getCancellationToken?(): CancellationToken;

+>getCancellationToken : () => CancellationToken
+>CancellationToken : CancellationToken
+
+        getCurrentDirectory(): string;

+>getCurrentDirectory : () => string
+
+        getDefaultLibFilename(options: CompilerOptions): string;

+>getDefaultLibFilename : (options: CompilerOptions) => string
+>options : CompilerOptions
+>CompilerOptions : CompilerOptions
+    }

+    interface LanguageService {

+>LanguageService : LanguageService
+
+        cleanupSemanticCache(): void;

+>cleanupSemanticCache : () => void
+
+        getSyntacticDiagnostics(fileName: string): Diagnostic[];

+>getSyntacticDiagnostics : (fileName: string) => Diagnostic[]
+>fileName : string
+>Diagnostic : Diagnostic
+
+        getSemanticDiagnostics(fileName: string): Diagnostic[];

+>getSemanticDiagnostics : (fileName: string) => Diagnostic[]
+>fileName : string
+>Diagnostic : Diagnostic
+
+        getCompilerOptionsDiagnostics(): Diagnostic[];

+>getCompilerOptionsDiagnostics : () => Diagnostic[]
+>Diagnostic : Diagnostic
+
+        getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];

+>getSyntacticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[]
+>fileName : string
+>span : TextSpan
+>TextSpan : TextSpan
+>ClassifiedSpan : ClassifiedSpan
+
+        getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];

+>getSemanticClassifications : (fileName: string, span: TextSpan) => ClassifiedSpan[]
+>fileName : string
+>span : TextSpan
+>TextSpan : TextSpan
+>ClassifiedSpan : ClassifiedSpan
+
+        getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;

+>getCompletionsAtPosition : (fileName: string, position: number) => CompletionInfo
+>fileName : string
+>position : number
+>CompletionInfo : CompletionInfo
+
+        getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;

+>getCompletionEntryDetails : (fileName: string, position: number, entryName: string) => CompletionEntryDetails
+>fileName : string
+>position : number
+>entryName : string
+>CompletionEntryDetails : CompletionEntryDetails
+
+        getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;

+>getQuickInfoAtPosition : (fileName: string, position: number) => QuickInfo
+>fileName : string
+>position : number
+>QuickInfo : QuickInfo
+
+        getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;

+>getNameOrDottedNameSpan : (fileName: string, startPos: number, endPos: number) => TextSpan
+>fileName : string
+>startPos : number
+>endPos : number
+>TextSpan : TextSpan
+
+        getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;

+>getBreakpointStatementAtPosition : (fileName: string, position: number) => TextSpan
+>fileName : string
+>position : number
+>TextSpan : TextSpan
+
+        getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;

+>getSignatureHelpItems : (fileName: string, position: number) => SignatureHelpItems
+>fileName : string
+>position : number
+>SignatureHelpItems : SignatureHelpItems
+
+        getRenameInfo(fileName: string, position: number): RenameInfo;

+>getRenameInfo : (fileName: string, position: number) => RenameInfo
+>fileName : string
+>position : number
+>RenameInfo : RenameInfo
+
+        findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];

+>findRenameLocations : (fileName: string, position: number, findInStrings: boolean, findInComments: boolean) => RenameLocation[]
+>fileName : string
+>position : number
+>findInStrings : boolean
+>findInComments : boolean
+>RenameLocation : RenameLocation
+
+        getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];

+>getDefinitionAtPosition : (fileName: string, position: number) => DefinitionInfo[]
+>fileName : string
+>position : number
+>DefinitionInfo : DefinitionInfo
+
+        getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];

+>getReferencesAtPosition : (fileName: string, position: number) => ReferenceEntry[]
+>fileName : string
+>position : number
+>ReferenceEntry : ReferenceEntry
+
+        getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];

+>getOccurrencesAtPosition : (fileName: string, position: number) => ReferenceEntry[]
+>fileName : string
+>position : number
+>ReferenceEntry : ReferenceEntry
+
+        getNavigateToItems(searchValue: string): NavigateToItem[];

+>getNavigateToItems : (searchValue: string) => NavigateToItem[]
+>searchValue : string
+>NavigateToItem : NavigateToItem
+
+        getNavigationBarItems(fileName: string): NavigationBarItem[];

+>getNavigationBarItems : (fileName: string) => NavigationBarItem[]
+>fileName : string
+>NavigationBarItem : NavigationBarItem
+
+        getOutliningSpans(fileName: string): OutliningSpan[];

+>getOutliningSpans : (fileName: string) => OutliningSpan[]
+>fileName : string
+>OutliningSpan : OutliningSpan
+
+        getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];

+>getTodoComments : (fileName: string, descriptors: TodoCommentDescriptor[]) => TodoComment[]
+>fileName : string
+>descriptors : TodoCommentDescriptor[]
+>TodoCommentDescriptor : TodoCommentDescriptor
+>TodoComment : TodoComment
+
+        getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];

+>getBraceMatchingAtPosition : (fileName: string, position: number) => TextSpan[]
+>fileName : string
+>position : number
+>TextSpan : TextSpan
+
+        getIndentationAtPosition(fileName: string, position: number, options: EditorOptions): number;

+>getIndentationAtPosition : (fileName: string, position: number, options: EditorOptions) => number
+>fileName : string
+>position : number
+>options : EditorOptions
+>EditorOptions : EditorOptions
+
+        getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsForRange : (fileName: string, start: number, end: number, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>start : number
+>end : number
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsForDocument : (fileName: string, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions): TextChange[];

+>getFormattingEditsAfterKeystroke : (fileName: string, position: number, key: string, options: FormatCodeOptions) => TextChange[]
+>fileName : string
+>position : number
+>key : string
+>options : FormatCodeOptions
+>FormatCodeOptions : FormatCodeOptions
+>TextChange : TextChange
+
+        getEmitOutput(fileName: string): EmitOutput;

+>getEmitOutput : (fileName: string) => EmitOutput
+>fileName : string
+>EmitOutput : EmitOutput
+
+        getSourceFile(filename: string): SourceFile;

+>getSourceFile : (filename: string) => SourceFile
+>filename : string
+>SourceFile : SourceFile
+
+        dispose(): void;

+>dispose : () => void
+    }

+    class TextSpan {

+>TextSpan : TextSpan
+
+        private _start;

+>_start : any
+
+        private _length;

+>_length : any
+
+        /**

+            * Creates a TextSpan instance beginning with the position Start and having the Length

+            * specified with length.

+            */

+        constructor(start: number, length: number);

+>start : number
+>length : number
+
+        toJSON(key: any): any;

+>toJSON : (key: any) => any
+>key : any
+
+        start(): number;

+>start : () => number
+
+        length(): number;

+>length : () => number
+
+        end(): number;

+>end : () => number
+
+        isEmpty(): boolean;

+>isEmpty : () => boolean
+
+        /**

+            * Determines whether the position lies within the span. Returns true if the position is greater than or equal to Start and strictly less

+            * than End, otherwise false.

+            * @param position The position to check.

+            */

+        containsPosition(position: number): boolean;

+>containsPosition : (position: number) => boolean
+>position : number
+
+        /**

+            * Determines whether span falls completely within this span. Returns true if the specified span falls completely within this span, otherwise false.

+            * @param span The span to check.

+            */

+        containsTextSpan(span: TextSpan): boolean;

+>containsTextSpan : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Determines whether the given span overlaps this span. Two spans are considered to overlap

+            * if they have positions in common and neither is empty. Empty spans do not overlap with any

+            * other span. Returns true if the spans overlap, false otherwise.

+            * @param span The span to check.

+            */

+        overlapsWith(span: TextSpan): boolean;

+>overlapsWith : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Returns the overlap with the given span, or undefined if there is no overlap.

+            * @param span The span to check.

+            */

+        overlap(span: TextSpan): TextSpan;

+>overlap : (span: TextSpan) => TextSpan
+>span : TextSpan
+>TextSpan : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Determines whether span intersects this span. Two spans are considered to

+            * intersect if they have positions in common or the end of one span

+            * coincides with the start of the other span. Returns true if the spans intersect, false otherwise.

+            * @param The span to check.

+            */

+        intersectsWithTextSpan(span: TextSpan): boolean;

+>intersectsWithTextSpan : (span: TextSpan) => boolean
+>span : TextSpan
+>TextSpan : TextSpan
+
+        intersectsWith(start: number, length: number): boolean;

+>intersectsWith : (start: number, length: number) => boolean
+>start : number
+>length : number
+
+        /**

+            * Determines whether the given position intersects this span.

+            * A position is considered to intersect if it is between the start and

+            * end positions (inclusive) of this span. Returns true if the position intersects, false otherwise.

+            * @param position The position to check.

+            */

+        intersectsWithPosition(position: number): boolean;

+>intersectsWithPosition : (position: number) => boolean
+>position : number
+
+        /**

+            * Returns the intersection with the given span, or undefined if there is no intersection.

+            * @param span The span to check.

+            */

+        intersection(span: TextSpan): TextSpan;

+>intersection : (span: TextSpan) => TextSpan
+>span : TextSpan
+>TextSpan : TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Creates a new TextSpan from the given start and end positions

+            * as opposed to a position and length.

+            */

+        static fromBounds(start: number, end: number): TextSpan;

+>fromBounds : (start: number, end: number) => TextSpan
+>start : number
+>end : number
+>TextSpan : TextSpan
+    }

+    class TextChangeRange {

+>TextChangeRange : TextChangeRange
+
+        static unchanged: TextChangeRange;

+>unchanged : TextChangeRange
+>TextChangeRange : TextChangeRange
+
+        private _span;

+>_span : any
+
+        private _newLength;

+>_newLength : any
+
+        /**

+            * Initializes a new instance of TextChangeRange.

+            */

+        constructor(span: TextSpan, newLength: number);

+>span : TextSpan
+>TextSpan : TextSpan
+>newLength : number
+
+        /**

+            * The span of text before the edit which is being changed

+            */

+        span(): TextSpan;

+>span : () => TextSpan
+>TextSpan : TextSpan
+
+        /**

+            * Width of the span after the edit.  A 0 here would represent a delete

+            */

+        newLength(): number;

+>newLength : () => number
+
+        newSpan(): TextSpan;

+>newSpan : () => TextSpan
+>TextSpan : TextSpan
+
+        isUnchanged(): boolean;

+>isUnchanged : () => boolean
+
+        /**

+            * Called to merge all the changes that occurred across several versions of a script snapshot

+            * into a single change.  i.e. if a user keeps making successive edits to a script we will

+            * have a text change from V1 to V2, V2 to V3, ..., Vn.

+            *

+            * This function will then merge those changes into a single change range valid between V1 and

+            * Vn.

+            */

+        static collapseChangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;

+>collapseChangesAcrossMultipleVersions : (changes: TextChangeRange[]) => TextChangeRange
+>changes : TextChangeRange[]
+>TextChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+    }

+    interface ClassifiedSpan {

+>ClassifiedSpan : ClassifiedSpan
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        classificationType: string;

+>classificationType : string
+    }

+    interface NavigationBarItem {

+>NavigationBarItem : NavigationBarItem
+
+        text: string;

+>text : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        spans: TextSpan[];

+>spans : TextSpan[]
+>TextSpan : TextSpan
+
+        childItems: NavigationBarItem[];

+>childItems : NavigationBarItem[]
+>NavigationBarItem : NavigationBarItem
+
+        indent: number;

+>indent : number
+
+        bolded: boolean;

+>bolded : boolean
+
+        grayed: boolean;

+>grayed : boolean
+    }

+    interface TodoCommentDescriptor {

+>TodoCommentDescriptor : TodoCommentDescriptor
+
+        text: string;

+>text : string
+
+        priority: number;

+>priority : number
+    }

+    interface TodoComment {

+>TodoComment : TodoComment
+
+        descriptor: TodoCommentDescriptor;

+>descriptor : TodoCommentDescriptor
+>TodoCommentDescriptor : TodoCommentDescriptor
+
+        message: string;

+>message : string
+
+        position: number;

+>position : number
+    }

+    class TextChange {

+>TextChange : TextChange
+
+        span: TextSpan;

+>span : TextSpan
+>TextSpan : TextSpan
+
+        newText: string;

+>newText : string
+    }

+    interface RenameLocation {

+>RenameLocation : RenameLocation
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        fileName: string;

+>fileName : string
+    }

+    interface ReferenceEntry {

+>ReferenceEntry : ReferenceEntry
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        fileName: string;

+>fileName : string
+
+        isWriteAccess: boolean;

+>isWriteAccess : boolean
+    }

+    interface NavigateToItem {

+>NavigateToItem : NavigateToItem
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        matchKind: string;

+>matchKind : string
+
+        fileName: string;

+>fileName : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        containerName: string;

+>containerName : string
+
+        containerKind: string;

+>containerKind : string
+    }

+    interface EditorOptions {

+>EditorOptions : EditorOptions
+
+        IndentSize: number;

+>IndentSize : number
+
+        TabSize: number;

+>TabSize : number
+
+        NewLineCharacter: string;

+>NewLineCharacter : string
+
+        ConvertTabsToSpaces: boolean;

+>ConvertTabsToSpaces : boolean
+    }

+    interface FormatCodeOptions extends EditorOptions {

+>FormatCodeOptions : FormatCodeOptions
+>EditorOptions : EditorOptions
+
+        InsertSpaceAfterCommaDelimiter: boolean;

+>InsertSpaceAfterCommaDelimiter : boolean
+
+        InsertSpaceAfterSemicolonInForStatements: boolean;

+>InsertSpaceAfterSemicolonInForStatements : boolean
+
+        InsertSpaceBeforeAndAfterBinaryOperators: boolean;

+>InsertSpaceBeforeAndAfterBinaryOperators : boolean
+
+        InsertSpaceAfterKeywordsInControlFlowStatements: boolean;

+>InsertSpaceAfterKeywordsInControlFlowStatements : boolean
+
+        InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;

+>InsertSpaceAfterFunctionKeywordForAnonymousFunctions : boolean
+
+        InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;

+>InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis : boolean
+
+        PlaceOpenBraceOnNewLineForFunctions: boolean;

+>PlaceOpenBraceOnNewLineForFunctions : boolean
+
+        PlaceOpenBraceOnNewLineForControlBlocks: boolean;

+>PlaceOpenBraceOnNewLineForControlBlocks : boolean
+    }

+    interface DefinitionInfo {

+>DefinitionInfo : DefinitionInfo
+
+        fileName: string;

+>fileName : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        kind: string;

+>kind : string
+
+        name: string;

+>name : string
+
+        containerKind: string;

+>containerKind : string
+
+        containerName: string;

+>containerName : string
+    }

+    enum SymbolDisplayPartKind {

+>SymbolDisplayPartKind : SymbolDisplayPartKind
+
+        aliasName = 0,

+>aliasName : SymbolDisplayPartKind
+
+        className = 1,

+>className : SymbolDisplayPartKind
+
+        enumName = 2,

+>enumName : SymbolDisplayPartKind
+
+        fieldName = 3,

+>fieldName : SymbolDisplayPartKind
+
+        interfaceName = 4,

+>interfaceName : SymbolDisplayPartKind
+
+        keyword = 5,

+>keyword : SymbolDisplayPartKind
+
+        lineBreak = 6,

+>lineBreak : SymbolDisplayPartKind
+
+        numericLiteral = 7,

+>numericLiteral : SymbolDisplayPartKind
+
+        stringLiteral = 8,

+>stringLiteral : SymbolDisplayPartKind
+
+        localName = 9,

+>localName : SymbolDisplayPartKind
+
+        methodName = 10,

+>methodName : SymbolDisplayPartKind
+
+        moduleName = 11,

+>moduleName : SymbolDisplayPartKind
+
+        operator = 12,

+>operator : SymbolDisplayPartKind
+
+        parameterName = 13,

+>parameterName : SymbolDisplayPartKind
+
+        propertyName = 14,

+>propertyName : SymbolDisplayPartKind
+
+        punctuation = 15,

+>punctuation : SymbolDisplayPartKind
+
+        space = 16,

+>space : SymbolDisplayPartKind
+
+        text = 17,

+>text : SymbolDisplayPartKind
+
+        typeParameterName = 18,

+>typeParameterName : SymbolDisplayPartKind
+
+        enumMemberName = 19,

+>enumMemberName : SymbolDisplayPartKind
+
+        functionName = 20,

+>functionName : SymbolDisplayPartKind
+
+        regularExpressionLiteral = 21,

+>regularExpressionLiteral : SymbolDisplayPartKind
+    }

+    interface SymbolDisplayPart {

+>SymbolDisplayPart : SymbolDisplayPart
+
+        text: string;

+>text : string
+
+        kind: string;

+>kind : string
+    }

+    interface QuickInfo {

+>QuickInfo : QuickInfo
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface RenameInfo {

+>RenameInfo : RenameInfo
+
+        canRename: boolean;

+>canRename : boolean
+
+        localizedErrorMessage: string;

+>localizedErrorMessage : string
+
+        displayName: string;

+>displayName : string
+
+        fullDisplayName: string;

+>fullDisplayName : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        triggerSpan: TextSpan;

+>triggerSpan : TextSpan
+>TextSpan : TextSpan
+    }

+    interface SignatureHelpParameter {

+>SignatureHelpParameter : SignatureHelpParameter
+
+        name: string;

+>name : string
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        isOptional: boolean;

+>isOptional : boolean
+    }

+    /**

+     * Represents a single signature to show in signature help.

+     * The id is used for subsequent calls into the language service to ask questions about the

+     * signature help item in the context of any documents that have been updated.  i.e. after

+     * an edit has happened, while signature help is still active, the host can ask important

+     * questions like 'what parameter is the user currently contained within?'.

+     */

+    interface SignatureHelpItem {

+>SignatureHelpItem : SignatureHelpItem
+
+        isVariadic: boolean;

+>isVariadic : boolean
+
+        prefixDisplayParts: SymbolDisplayPart[];

+>prefixDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        suffixDisplayParts: SymbolDisplayPart[];

+>suffixDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        separatorDisplayParts: SymbolDisplayPart[];

+>separatorDisplayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        parameters: SignatureHelpParameter[];

+>parameters : SignatureHelpParameter[]
+>SignatureHelpParameter : SignatureHelpParameter
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    /**

+     * Represents a set of signature help items, and the preferred item that should be selected.

+     */

+    interface SignatureHelpItems {

+>SignatureHelpItems : SignatureHelpItems
+
+        items: SignatureHelpItem[];

+>items : SignatureHelpItem[]
+>SignatureHelpItem : SignatureHelpItem
+
+        applicableSpan: TextSpan;

+>applicableSpan : TextSpan
+>TextSpan : TextSpan
+
+        selectedItemIndex: number;

+>selectedItemIndex : number
+
+        argumentIndex: number;

+>argumentIndex : number
+
+        argumentCount: number;

+>argumentCount : number
+    }

+    interface CompletionInfo {

+>CompletionInfo : CompletionInfo
+
+        isMemberCompletion: boolean;

+>isMemberCompletion : boolean
+
+        entries: CompletionEntry[];

+>entries : CompletionEntry[]
+>CompletionEntry : CompletionEntry
+    }

+    interface CompletionEntry {

+>CompletionEntry : CompletionEntry
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+    }

+    interface CompletionEntryDetails {

+>CompletionEntryDetails : CompletionEntryDetails
+
+        name: string;

+>name : string
+
+        kind: string;

+>kind : string
+
+        kindModifiers: string;

+>kindModifiers : string
+
+        displayParts: SymbolDisplayPart[];

+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+        documentation: SymbolDisplayPart[];

+>documentation : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    interface OutliningSpan {

+>OutliningSpan : OutliningSpan
+
+        /** The span of the document to actually collapse. */

+        textSpan: TextSpan;

+>textSpan : TextSpan
+>TextSpan : TextSpan
+
+        /** The span of the document to display when the user hovers over the collapsed span. */

+        hintSpan: TextSpan;

+>hintSpan : TextSpan
+>TextSpan : TextSpan
+
+        /** The text to display in the editor for the collapsed region. */

+        bannerText: string;

+>bannerText : string
+
+        /**

+          * Whether or not this region should be automatically collapsed when

+          * the 'Collapse to Definitions' command is invoked.

+          */

+        autoCollapse: boolean;

+>autoCollapse : boolean
+    }

+    interface EmitOutput {

+>EmitOutput : EmitOutput
+
+        outputFiles: OutputFile[];

+>outputFiles : OutputFile[]
+>OutputFile : OutputFile
+
+        emitOutputStatus: EmitReturnStatus;

+>emitOutputStatus : EmitReturnStatus
+>EmitReturnStatus : EmitReturnStatus
+    }

+    const enum OutputFileType {

+>OutputFileType : OutputFileType
+
+        JavaScript = 0,

+>JavaScript : OutputFileType
+
+        SourceMap = 1,

+>SourceMap : OutputFileType
+
+        Declaration = 2,

+>Declaration : OutputFileType
+    }

+    interface OutputFile {

+>OutputFile : OutputFile
+
+        name: string;

+>name : string
+
+        writeByteOrderMark: boolean;

+>writeByteOrderMark : boolean
+
+        text: string;

+>text : string
+    }

+    const enum EndOfLineState {

+>EndOfLineState : EndOfLineState
+
+        Start = 0,

+>Start : EndOfLineState
+
+        InMultiLineCommentTrivia = 1,

+>InMultiLineCommentTrivia : EndOfLineState
+
+        InSingleQuoteStringLiteral = 2,

+>InSingleQuoteStringLiteral : EndOfLineState
+
+        InDoubleQuoteStringLiteral = 3,

+>InDoubleQuoteStringLiteral : EndOfLineState
+    }

+    enum TokenClass {

+>TokenClass : TokenClass
+
+        Punctuation = 0,

+>Punctuation : TokenClass
+
+        Keyword = 1,

+>Keyword : TokenClass
+
+        Operator = 2,

+>Operator : TokenClass
+
+        Comment = 3,

+>Comment : TokenClass
+
+        Whitespace = 4,

+>Whitespace : TokenClass
+
+        Identifier = 5,

+>Identifier : TokenClass
+
+        NumberLiteral = 6,

+>NumberLiteral : TokenClass
+
+        StringLiteral = 7,

+>StringLiteral : TokenClass
+
+        RegExpLiteral = 8,

+>RegExpLiteral : TokenClass
+    }

+    interface ClassificationResult {

+>ClassificationResult : ClassificationResult
+
+        finalLexState: EndOfLineState;

+>finalLexState : EndOfLineState
+>EndOfLineState : EndOfLineState
+
+        entries: ClassificationInfo[];

+>entries : ClassificationInfo[]
+>ClassificationInfo : ClassificationInfo
+    }

+    interface ClassificationInfo {

+>ClassificationInfo : ClassificationInfo
+
+        length: number;

+>length : number
+
+        classification: TokenClass;

+>classification : TokenClass
+>TokenClass : TokenClass
+    }

+    interface Classifier {

+>Classifier : Classifier
+
+        getClassificationsForLine(text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean): ClassificationResult;

+>getClassificationsForLine : (text: string, lexState: EndOfLineState, classifyKeywordsInGenerics?: boolean) => ClassificationResult
+>text : string
+>lexState : EndOfLineState
+>EndOfLineState : EndOfLineState
+>classifyKeywordsInGenerics : boolean
+>ClassificationResult : ClassificationResult
+    }

+    interface DocumentRegistry {

+>DocumentRegistry : DocumentRegistry
+
+        acquireDocument(filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean): SourceFile;

+>acquireDocument : (filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean) => SourceFile
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>SourceFile : SourceFile
+
+        updateDocument(sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange): SourceFile;

+>updateDocument : (sourceFile: SourceFile, filename: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, isOpen: boolean, textChangeRange: TextChangeRange) => SourceFile
+>sourceFile : SourceFile
+>SourceFile : SourceFile
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+>scriptSnapshot : IScriptSnapshot
+>IScriptSnapshot : IScriptSnapshot
+>version : string
+>isOpen : boolean
+>textChangeRange : TextChangeRange
+>TextChangeRange : TextChangeRange
+>SourceFile : SourceFile
+
+        releaseDocument(filename: string, compilationSettings: CompilerOptions): void;

+>releaseDocument : (filename: string, compilationSettings: CompilerOptions) => void
+>filename : string
+>compilationSettings : CompilerOptions
+>CompilerOptions : CompilerOptions
+    }

+    class ScriptElementKind {

+>ScriptElementKind : ScriptElementKind
+
+        static unknown: string;

+>unknown : string
+
+        static keyword: string;

+>keyword : string
+
+        static scriptElement: string;

+>scriptElement : string
+
+        static moduleElement: string;

+>moduleElement : string
+
+        static classElement: string;

+>classElement : string
+
+        static interfaceElement: string;

+>interfaceElement : string
+
+        static typeElement: string;

+>typeElement : string
+
+        static enumElement: string;

+>enumElement : string
+
+        static variableElement: string;

+>variableElement : string
+
+        static localVariableElement: string;

+>localVariableElement : string
+
+        static functionElement: string;

+>functionElement : string
+
+        static localFunctionElement: string;

+>localFunctionElement : string
+
+        static memberFunctionElement: string;

+>memberFunctionElement : string
+
+        static memberGetAccessorElement: string;

+>memberGetAccessorElement : string
+
+        static memberSetAccessorElement: string;

+>memberSetAccessorElement : string
+
+        static memberVariableElement: string;

+>memberVariableElement : string
+
+        static constructorImplementationElement: string;

+>constructorImplementationElement : string
+
+        static callSignatureElement: string;

+>callSignatureElement : string
+
+        static indexSignatureElement: string;

+>indexSignatureElement : string
+
+        static constructSignatureElement: string;

+>constructSignatureElement : string
+
+        static parameterElement: string;

+>parameterElement : string
+
+        static typeParameterElement: string;

+>typeParameterElement : string
+
+        static primitiveType: string;

+>primitiveType : string
+
+        static label: string;

+>label : string
+
+        static alias: string;

+>alias : string
+
+        static constElement: string;

+>constElement : string
+
+        static letElement: string;

+>letElement : string
+    }

+    class ScriptElementKindModifier {

+>ScriptElementKindModifier : ScriptElementKindModifier
+
+        static none: string;

+>none : string
+
+        static publicMemberModifier: string;

+>publicMemberModifier : string
+
+        static privateMemberModifier: string;

+>privateMemberModifier : string
+
+        static protectedMemberModifier: string;

+>protectedMemberModifier : string
+
+        static exportedModifier: string;

+>exportedModifier : string
+
+        static ambientModifier: string;

+>ambientModifier : string
+
+        static staticModifier: string;

+>staticModifier : string
+    }

+    class ClassificationTypeNames {

+>ClassificationTypeNames : ClassificationTypeNames
+
+        static comment: string;

+>comment : string
+
+        static identifier: string;

+>identifier : string
+
+        static keyword: string;

+>keyword : string
+
+        static numericLiteral: string;

+>numericLiteral : string
+
+        static operator: string;

+>operator : string
+
+        static stringLiteral: string;

+>stringLiteral : string
+
+        static whiteSpace: string;

+>whiteSpace : string
+
+        static text: string;

+>text : string
+
+        static punctuation: string;

+>punctuation : string
+
+        static className: string;

+>className : string
+
+        static enumName: string;

+>enumName : string
+
+        static interfaceName: string;

+>interfaceName : string
+
+        static moduleName: string;

+>moduleName : string
+
+        static typeParameterName: string;

+>typeParameterName : string
+
+        static typeAlias: string;

+>typeAlias : string
+    }

+    interface DisplayPartsSymbolWriter extends SymbolWriter {

+>DisplayPartsSymbolWriter : DisplayPartsSymbolWriter
+>SymbolWriter : SymbolWriter
+
+        displayParts(): SymbolDisplayPart[];

+>displayParts : () => SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+    }

+    function displayPartsToString(displayParts: SymbolDisplayPart[]): string;

+>displayPartsToString : (displayParts: SymbolDisplayPart[]) => string
+>displayParts : SymbolDisplayPart[]
+>SymbolDisplayPart : SymbolDisplayPart
+
+    function getDefaultCompilerOptions(): CompilerOptions;

+>getDefaultCompilerOptions : () => CompilerOptions
+>CompilerOptions : CompilerOptions
+
+    class OperationCanceledException {

+>OperationCanceledException : OperationCanceledException
+    }

+    class CancellationTokenObject {

+>CancellationTokenObject : CancellationTokenObject
+
+        private cancellationToken;

+>cancellationToken : any
+
+        static None: CancellationTokenObject;

+>None : CancellationTokenObject
+>CancellationTokenObject : CancellationTokenObject
+
+        constructor(cancellationToken: CancellationToken);

+>cancellationToken : CancellationToken
+>CancellationToken : CancellationToken
+
+        isCancellationRequested(): boolean;

+>isCancellationRequested : () => boolean
+
+        throwIfCancellationRequested(): void;

+>throwIfCancellationRequested : () => void
+    }

+    function createDocumentRegistry(): DocumentRegistry;

+>createDocumentRegistry : () => DocumentRegistry
+>DocumentRegistry : DocumentRegistry
+
+    function preProcessFile(sourceText: string, readImportFiles?: boolean): PreProcessedFileInfo;

+>preProcessFile : (sourceText: string, readImportFiles?: boolean) => PreProcessedFileInfo
+>sourceText : string
+>readImportFiles : boolean
+>PreProcessedFileInfo : PreProcessedFileInfo
+
+    function createLanguageService(host: LanguageServiceHost, documentRegistry: DocumentRegistry): LanguageService;

+>createLanguageService : (host: LanguageServiceHost, documentRegistry: DocumentRegistry) => LanguageService
+>host : LanguageServiceHost
+>LanguageServiceHost : LanguageServiceHost
+>documentRegistry : DocumentRegistry
+>DocumentRegistry : DocumentRegistry
+>LanguageService : LanguageService
+
+    function createClassifier(host: Logger): Classifier;

+>createClassifier : (host: Logger) => Classifier
+>host : Logger
+>Logger : Logger
+>Classifier : Classifier
+}

+
diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js
new file mode 100644
index 00000000000..5185a9b8db8
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.js
@@ -0,0 +1,81 @@
+//// [noImplicitAnyIndexingSuppressed.ts]
+
+enum MyEmusEnum {
+    emu
+}
+
+// Should be okay; should be a string.
+var strRepresentation1 = MyEmusEnum[0]
+
+// Should be okay; should be a string.
+var strRepresentation2 = MyEmusEnum[MyEmusEnum.emu]
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var strRepresentation3 = MyEmusEnum["monehh"];
+
+// Should be okay; should be a MyEmusEnum
+var strRepresentation4 = MyEmusEnum["emu"];
+
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var x = {}["hi"];
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var y = {}[10];
+
+var hi: any = "hi";
+
+var emptyObj = {};
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var z1 = emptyObj[hi];
+var z2 = (<any>emptyObj)[hi];
+
+interface MyMap<T> {
+    [key: string]: T;
+}
+
+var m: MyMap<number> = {
+    "0": 0,
+    "1": 1,
+    "2": 2,
+    "Okay that's enough for today.": NaN
+};
+
+var mResult1 = m[MyEmusEnum.emu];
+var mResult2 = m[MyEmusEnum[MyEmusEnum.emu]];
+var mResult3 = m[hi];
+
+
+
+//// [noImplicitAnyIndexingSuppressed.js]
+var MyEmusEnum;
+(function (MyEmusEnum) {
+    MyEmusEnum[MyEmusEnum["emu"] = 0] = "emu";
+})(MyEmusEnum || (MyEmusEnum = {}));
+// Should be okay; should be a string.
+var strRepresentation1 = MyEmusEnum[0];
+// Should be okay; should be a string.
+var strRepresentation2 = MyEmusEnum[0 /* emu */];
+// Should be okay, as we suppress implicit 'any' property access checks
+var strRepresentation3 = MyEmusEnum["monehh"];
+// Should be okay; should be a MyEmusEnum
+var strRepresentation4 = 0 /* "emu" */;
+// Should be okay, as we suppress implicit 'any' property access checks
+var x = {}["hi"];
+// Should be okay, as we suppress implicit 'any' property access checks
+var y = {}[10];
+var hi = "hi";
+var emptyObj = {};
+// Should be okay, as we suppress implicit 'any' property access checks
+var z1 = emptyObj[hi];
+var z2 = emptyObj[hi];
+var m = {
+    "0": 0,
+    "1": 1,
+    "2": 2,
+    "Okay that's enough for today.": NaN
+};
+var mResult1 = m[0 /* emu */];
+var mResult2 = m[MyEmusEnum[0 /* emu */]];
+var mResult3 = m[hi];
diff --git a/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types
new file mode 100644
index 00000000000..20be75dc29e
--- /dev/null
+++ b/tests/baselines/reference/noImplicitAnyIndexingSuppressed.types
@@ -0,0 +1,118 @@
+=== tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts ===
+
+enum MyEmusEnum {
+>MyEmusEnum : MyEmusEnum
+
+    emu
+>emu : MyEmusEnum
+}
+
+// Should be okay; should be a string.
+var strRepresentation1 = MyEmusEnum[0]
+>strRepresentation1 : string
+>MyEmusEnum[0] : string
+>MyEmusEnum : typeof MyEmusEnum
+
+// Should be okay; should be a string.
+var strRepresentation2 = MyEmusEnum[MyEmusEnum.emu]
+>strRepresentation2 : string
+>MyEmusEnum[MyEmusEnum.emu] : string
+>MyEmusEnum : typeof MyEmusEnum
+>MyEmusEnum.emu : MyEmusEnum
+>MyEmusEnum : typeof MyEmusEnum
+>emu : MyEmusEnum
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var strRepresentation3 = MyEmusEnum["monehh"];
+>strRepresentation3 : any
+>MyEmusEnum["monehh"] : any
+>MyEmusEnum : typeof MyEmusEnum
+
+// Should be okay; should be a MyEmusEnum
+var strRepresentation4 = MyEmusEnum["emu"];
+>strRepresentation4 : MyEmusEnum
+>MyEmusEnum["emu"] : MyEmusEnum
+>MyEmusEnum : typeof MyEmusEnum
+
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var x = {}["hi"];
+>x : any
+>{}["hi"] : any
+>{} : {}
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var y = {}[10];
+>y : any
+>{}[10] : any
+>{} : {}
+
+var hi: any = "hi";
+>hi : any
+
+var emptyObj = {};
+>emptyObj : {}
+>{} : {}
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var z1 = emptyObj[hi];
+>z1 : any
+>emptyObj[hi] : any
+>emptyObj : {}
+>hi : any
+
+var z2 = (<any>emptyObj)[hi];
+>z2 : any
+>(<any>emptyObj)[hi] : any
+>(<any>emptyObj) : any
+><any>emptyObj : any
+>emptyObj : {}
+>hi : any
+
+interface MyMap<T> {
+>MyMap : MyMap<T>
+>T : T
+
+    [key: string]: T;
+>key : string
+>T : T
+}
+
+var m: MyMap<number> = {
+>m : MyMap<number>
+>MyMap : MyMap<T>
+>{    "0": 0,    "1": 1,    "2": 2,    "Okay that's enough for today.": NaN} : { [x: string]: number; "0": number; "1": number; "2": number; "Okay that's enough for today.": number; }
+
+    "0": 0,
+    "1": 1,
+    "2": 2,
+    "Okay that's enough for today.": NaN
+>NaN : number
+
+};
+
+var mResult1 = m[MyEmusEnum.emu];
+>mResult1 : number
+>m[MyEmusEnum.emu] : number
+>m : MyMap<number>
+>MyEmusEnum.emu : MyEmusEnum
+>MyEmusEnum : typeof MyEmusEnum
+>emu : MyEmusEnum
+
+var mResult2 = m[MyEmusEnum[MyEmusEnum.emu]];
+>mResult2 : number
+>m[MyEmusEnum[MyEmusEnum.emu]] : number
+>m : MyMap<number>
+>MyEmusEnum[MyEmusEnum.emu] : string
+>MyEmusEnum : typeof MyEmusEnum
+>MyEmusEnum.emu : MyEmusEnum
+>MyEmusEnum : typeof MyEmusEnum
+>emu : MyEmusEnum
+
+var mResult3 = m[hi];
+>mResult3 : number
+>m[hi] : number
+>m : MyMap<number>
+>hi : any
+
+
diff --git a/tests/baselines/reference/typeGuardsWithAny.js b/tests/baselines/reference/typeGuardsWithAny.js
new file mode 100644
index 00000000000..56676fb6d68
--- /dev/null
+++ b/tests/baselines/reference/typeGuardsWithAny.js
@@ -0,0 +1,18 @@
+//// [typeGuardsWithAny.ts]
+var x: any = { p: 0 };
+if (x instanceof Object) {
+    x.p; // No error, type any unaffected by type guard
+}
+else {
+    x.p; // No error, type any unaffected by type guard
+}
+
+
+//// [typeGuardsWithAny.js]
+var x = { p: 0 };
+if (x instanceof Object) {
+    x.p; // No error, type any unaffected by type guard
+}
+else {
+    x.p; // No error, type any unaffected by type guard
+}
diff --git a/tests/baselines/reference/typeGuardsWithAny.types b/tests/baselines/reference/typeGuardsWithAny.types
new file mode 100644
index 00000000000..ee628c9c249
--- /dev/null
+++ b/tests/baselines/reference/typeGuardsWithAny.types
@@ -0,0 +1,23 @@
+=== tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts ===
+var x: any = { p: 0 };
+>x : any
+>{ p: 0 } : { p: number; }
+>p : number
+
+if (x instanceof Object) {
+>x instanceof Object : boolean
+>x : any
+>Object : ObjectConstructor
+
+    x.p; // No error, type any unaffected by type guard
+>x.p : any
+>x : any
+>p : any
+}
+else {
+    x.p; // No error, type any unaffected by type guard
+>x.p : any
+>x : any
+>p : any
+}
+
diff --git a/tests/cases/compiler/APISample_node_compile.ts b/tests/cases/compiler/APISample_node_compile.ts
new file mode 100644
index 00000000000..b138ce2b44c
--- /dev/null
+++ b/tests/cases/compiler/APISample_node_compile.ts
@@ -0,0 +1,11 @@
+// @includeBuiltFile: typescript.d.ts
+// @noImplicitAny: true
+// @target: ES3
+// @module: CommonJs
+// @noresolve: true
+
+import ts = require("typescript");
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
\ No newline at end of file
diff --git a/tests/cases/compiler/APISample_standalone_compile.ts b/tests/cases/compiler/APISample_standalone_compile.ts
new file mode 100644
index 00000000000..049aae5523f
--- /dev/null
+++ b/tests/cases/compiler/APISample_standalone_compile.ts
@@ -0,0 +1,7 @@
+// @includeBuiltFile: typescriptServices.d.ts
+// @noImplicitAny: true
+// @target: ES3
+
+var sourceFile = ts.createSourceFile("file1.ts", "var x = 0;", ts.ScriptTarget.Latest, "0.0");
+
+var program = ts.createProgram(["file1.ts"], {}, undefined);
\ No newline at end of file
diff --git a/tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts b/tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts
new file mode 100644
index 00000000000..42ae529fddc
--- /dev/null
+++ b/tests/cases/compiler/noImplicitAnyIndexingSuppressed.ts
@@ -0,0 +1,49 @@
+//@noImplicitAny: true
+//@suppressImplicitAnyIndexErrors: true
+
+enum MyEmusEnum {
+    emu
+}
+
+// Should be okay; should be a string.
+var strRepresentation1 = MyEmusEnum[0]
+
+// Should be okay; should be a string.
+var strRepresentation2 = MyEmusEnum[MyEmusEnum.emu]
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var strRepresentation3 = MyEmusEnum["monehh"];
+
+// Should be okay; should be a MyEmusEnum
+var strRepresentation4 = MyEmusEnum["emu"];
+
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var x = {}["hi"];
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var y = {}[10];
+
+var hi: any = "hi";
+
+var emptyObj = {};
+
+// Should be okay, as we suppress implicit 'any' property access checks
+var z1 = emptyObj[hi];
+var z2 = (<any>emptyObj)[hi];
+
+interface MyMap<T> {
+    [key: string]: T;
+}
+
+var m: MyMap<number> = {
+    "0": 0,
+    "1": 1,
+    "2": 2,
+    "Okay that's enough for today.": NaN
+};
+
+var mResult1 = m[MyEmusEnum.emu];
+var mResult2 = m[MyEmusEnum[MyEmusEnum.emu]];
+var mResult3 = m[hi];
+
diff --git a/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts
new file mode 100644
index 00000000000..e7e756ea8e0
--- /dev/null
+++ b/tests/cases/conformance/expressions/typeGuards/typeGuardsWithAny.ts
@@ -0,0 +1,7 @@
+var x: any = { p: 0 };
+if (x instanceof Object) {
+    x.p; // No error, type any unaffected by type guard
+}
+else {
+    x.p; // No error, type any unaffected by type guard
+}