maxmustermann/TypeScript
1
0
Fork 0
Code Issues Pull requests Projects Releases Wiki Activity
TypeScript/tests/baselines/reference/APISample_transform.types
Cyrus Najmabadi a1e18fc22b Introduce a new HeritageClauseElment type. 
This type represents the expression+type arguments you can get in a class or interface
heritage clause section.  For class-implements clauses, or interface-extends clauses,
these expressions can only be identifiers or dotted names.  For class extends clauses,
these could be any expressions in the future.  However, for now, we only support identifiers
and dotted names.
2015-03-31 12:29:02 -07:00

6334 lines
175 KiB
Text
Raw Blame History

=== tests/cases/compiler/APISample_transform.ts ===
/*
* Note: This test is a public API sample. The sample sources can be found
at: https://github.com/Microsoft/TypeScript/wiki/Using-the-Compiler-API#a-simple-transform-function
* Please log a "breaking change" issue for any API breaking change affecting this issue
*/
declare var process: any;
>process : any
declare var console: any;
>console : any
declare var fs: any;
>fs : any
declare var path: any;
>path : any
declare var os: any;
>os : any
import ts = require("typescript");
>ts : typeof ts
function transform(contents: string, compilerOptions: ts.CompilerOptions = {}) {
>transform : (contents: string, compilerOptions?: ts.CompilerOptions) => { outputs: any[]; errors: string[]; }
>contents : string
>compilerOptions : ts.CompilerOptions
>ts : unknown
>CompilerOptions : ts.CompilerOptions
>{} : { [x: string]: undefined; }
// Sources
var files = {
>files : { "file.ts": string; "lib.d.ts": any; }
>{ "file.ts": contents, "lib.d.ts": fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions)).toString() } : { "file.ts": string; "lib.d.ts": any; }
"file.ts": contents,
>contents : string
"lib.d.ts": fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions)).toString()
>fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions)).toString() : any
>fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions)).toString : any
>fs.readFileSync(ts.getDefaultLibFilePath(compilerOptions)) : any
>fs.readFileSync : any
>fs : any
>readFileSync : any
>ts.getDefaultLibFilePath(compilerOptions) : string
>ts.getDefaultLibFilePath : (options: ts.CompilerOptions) => string
>ts : typeof ts
>getDefaultLibFilePath : (options: ts.CompilerOptions) => string
>compilerOptions : ts.CompilerOptions
>toString : any
};
// Generated outputs
var outputs = [];
>outputs : any[]
>[] : undefined[]
// Create a compilerHost object to allow the compiler to read and write files
var compilerHost = {
>compilerHost : { getSourceFile: (fileName: any, target: any) => ts.SourceFile; writeFile: (name: any, text: any, writeByteOrderMark: any) => void; getDefaultLibFileName: () => string; useCaseSensitiveFileNames: () => boolean; getCanonicalFileName: (fileName: any) => any; getCurrentDirectory: () => string; getNewLine: () => string; }
>{ getSourceFile: (fileName, target) => { return files[fileName] !== undefined ? ts.createSourceFile(fileName, files[fileName], target) : undefined; }, writeFile: (name, text, writeByteOrderMark) => { outputs.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); }, getDefaultLibFileName: () => "lib.d.ts", useCaseSensitiveFileNames: () => false, getCanonicalFileName: (fileName) => fileName, getCurrentDirectory: () => "", getNewLine: () => "\n" } : { getSourceFile: (fileName: any, target: any) => ts.SourceFile; writeFile: (name: any, text: any, writeByteOrderMark: any) => void; getDefaultLibFileName: () => string; useCaseSensitiveFileNames: () => boolean; getCanonicalFileName: (fileName: any) => any; getCurrentDirectory: () => string; getNewLine: () => string; }
getSourceFile: (fileName, target) => {
>getSourceFile : (fileName: any, target: any) => ts.SourceFile
>(fileName, target) => { return files[fileName] !== undefined ? ts.createSourceFile(fileName, files[fileName], target) : undefined; } : (fileName: any, target: any) => ts.SourceFile
>fileName : any
>target : any
return files[fileName] !== undefined ?
>files[fileName] !== undefined ? ts.createSourceFile(fileName, files[fileName], target) : undefined : ts.SourceFile
>files[fileName] !== undefined : boolean
>files[fileName] : any
>files : { "file.ts": string; "lib.d.ts": any; }
>fileName : any
>undefined : undefined
ts.createSourceFile(fileName, files[fileName], target) : undefined;
>ts.createSourceFile(fileName, files[fileName], target) : ts.SourceFile
>ts.createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
>ts : typeof ts
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ts.ScriptTarget, setParentNodes?: boolean) => ts.SourceFile
>fileName : any
>files[fileName] : any
>files : { "file.ts": string; "lib.d.ts": any; }
>fileName : any
>target : any
>undefined : undefined
},
writeFile: (name, text, writeByteOrderMark) => {
>writeFile : (name: any, text: any, writeByteOrderMark: any) => void
>(name, text, writeByteOrderMark) => { outputs.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }); } : (name: any, text: any, writeByteOrderMark: any) => void
>name : any
>text : any
>writeByteOrderMark : any
outputs.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark });
>outputs.push({ name: name, text: text, writeByteOrderMark: writeByteOrderMark }) : number
>outputs.push : (...items: any[]) => number
>outputs : any[]
>push : (...items: any[]) => number
>{ name: name, text: text, writeByteOrderMark: writeByteOrderMark } : { name: any; text: any; writeByteOrderMark: any; }
>name : any
>name : any
>text : any
>text : any
>writeByteOrderMark : any
>writeByteOrderMark : any
},
getDefaultLibFileName: () => "lib.d.ts",
>getDefaultLibFileName : () => string
>() => "lib.d.ts" : () => string
useCaseSensitiveFileNames: () => false,
>useCaseSensitiveFileNames : () => boolean
>() => false : () => boolean
getCanonicalFileName: (fileName) => fileName,
>getCanonicalFileName : (fileName: any) => any
>(fileName) => fileName : (fileName: any) => any
>fileName : any
>fileName : any
getCurrentDirectory: () => "",
>getCurrentDirectory : () => string
>() => "" : () => string
getNewLine: () => "\n"
>getNewLine : () => string
>() => "\n" : () => string
};
// Create a program from inputs
var program = ts.createProgram(["file.ts"], compilerOptions, compilerHost);
>program : ts.Program
>ts.createProgram(["file.ts"], compilerOptions, compilerHost) : 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
>["file.ts"] : string[]
>compilerOptions : ts.CompilerOptions
>compilerHost : { getSourceFile: (fileName: any, target: any) => ts.SourceFile; writeFile: (name: any, text: any, writeByteOrderMark: any) => void; getDefaultLibFileName: () => string; useCaseSensitiveFileNames: () => boolean; getCanonicalFileName: (fileName: any) => any; getCurrentDirectory: () => string; getNewLine: () => string; }
// Query for early errors
var errors = ts.getPreEmitDiagnostics(program);
>errors : ts.Diagnostic[]
>ts.getPreEmitDiagnostics(program) : ts.Diagnostic[]
>ts.getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
>ts : typeof ts
>getPreEmitDiagnostics : (program: ts.Program) => ts.Diagnostic[]
>program : ts.Program
var emitResult = program.emit();
>emitResult : ts.EmitResult
>program.emit() : ts.EmitResult
>program.emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
>program : ts.Program
>emit : (targetSourceFile?: ts.SourceFile, writeFile?: ts.WriteFileCallback) => ts.EmitResult
errors = errors.concat(emitResult.diagnostics);
>errors = errors.concat(emitResult.diagnostics) : ts.Diagnostic[]
>errors : ts.Diagnostic[]
>errors.concat(emitResult.diagnostics) : ts.Diagnostic[]
>errors.concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>errors : ts.Diagnostic[]
>concat : { <U extends ts.Diagnostic[]>(...items: U[]): ts.Diagnostic[]; (...items: ts.Diagnostic[]): ts.Diagnostic[]; }
>emitResult.diagnostics : ts.Diagnostic[]
>emitResult : ts.EmitResult
>diagnostics : ts.Diagnostic[]
return {
>{ outputs: outputs, errors: errors.map(function (e) { return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " + ts.flattenDiagnosticMessageText(e.messageText, os.EOL); }) } : { outputs: any[]; errors: string[]; }
outputs: outputs,
>outputs : any[]
>outputs : any[]
errors: errors.map(function (e) {
>errors : string[]
>errors.map(function (e) { return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " + ts.flattenDiagnosticMessageText(e.messageText, os.EOL); }) : string[]
>errors.map : <U>(callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => U, thisArg?: any) => U[]
>errors : ts.Diagnostic[]
>map : <U>(callbackfn: (value: ts.Diagnostic, index: number, array: ts.Diagnostic[]) => U, thisArg?: any) => U[]
>function (e) { return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " + ts.flattenDiagnosticMessageText(e.messageText, os.EOL); } : (e: ts.Diagnostic) => string
>e : ts.Diagnostic
return e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): "
>e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " + ts.flattenDiagnosticMessageText(e.messageText, os.EOL) : string
>e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) + "): " : string
>e.file.fileName + "(" + (e.file.getLineAndCharacterOfPosition(e.start).line + 1) : string
>e.file.fileName + "(" : string
>e.file.fileName : string
>e.file : ts.SourceFile
>e : ts.Diagnostic
>file : ts.SourceFile
>fileName : string
>(e.file.getLineAndCharacterOfPosition(e.start).line + 1) : number
>e.file.getLineAndCharacterOfPosition(e.start).line + 1 : number
>e.file.getLineAndCharacterOfPosition(e.start).line : number
>e.file.getLineAndCharacterOfPosition(e.start) : ts.LineAndCharacter
>e.file.getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>e.file : ts.SourceFile
>e : ts.Diagnostic
>file : ts.SourceFile
>getLineAndCharacterOfPosition : (pos: number) => ts.LineAndCharacter
>e.start : number
>e : ts.Diagnostic
>start : number
>line : number
+ ts.flattenDiagnosticMessageText(e.messageText, os.EOL);
>ts.flattenDiagnosticMessageText(e.messageText, os.EOL) : string
>ts.flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>ts : typeof ts
>flattenDiagnosticMessageText : (messageText: string | ts.DiagnosticMessageChain, newLine: string) => string
>e.messageText : string | ts.DiagnosticMessageChain
>e : ts.Diagnostic
>messageText : string | ts.DiagnosticMessageChain
>os.EOL : any
>os : any
>EOL : any
})
};
}
// Calling our transform function using a simple TypeScript variable declarations,
// and loading the default library like:
var source = "var x: number = 'string'";
>source : string
var result = transform(source);
>result : { outputs: any[]; errors: string[]; }
>transform(source) : { outputs: any[]; errors: string[]; }
>transform : (contents: string, compilerOptions?: ts.CompilerOptions) => { outputs: any[]; errors: string[]; }
>source : string
console.log(JSON.stringify(result));
>console.log(JSON.stringify(result)) : any
>console.log : any
>console : any
>log : any
>JSON.stringify(result) : string
>JSON.stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
>JSON : JSON
>stringify : { (value: any): string; (value: any, replacer: (key: string, value: any) => any): string; (value: any, replacer: any[]): string; (value: any, replacer: (key: string, value: any) => any, space: any): string; (value: any, replacer: any[], space: any): string; }
>result : { outputs: any[]; errors: string[]; }
=== 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
ConflictMarkerTrivia = 6,
>ConflictMarkerTrivia : SyntaxKind
NumericLiteral = 7,
>NumericLiteral : SyntaxKind
StringLiteral = 8,
>StringLiteral : SyntaxKind
RegularExpressionLiteral = 9,
>RegularExpressionLiteral : SyntaxKind
NoSubstitutionTemplateLiteral = 10,
>NoSubstitutionTemplateLiteral : SyntaxKind
TemplateHead = 11,
>TemplateHead : SyntaxKind
TemplateMiddle = 12,
>TemplateMiddle : SyntaxKind
TemplateTail = 13,
>TemplateTail : SyntaxKind
OpenBraceToken = 14,
>OpenBraceToken : SyntaxKind
CloseBraceToken = 15,
>CloseBraceToken : SyntaxKind
OpenParenToken = 16,
>OpenParenToken : SyntaxKind
CloseParenToken = 17,
>CloseParenToken : SyntaxKind
OpenBracketToken = 18,
>OpenBracketToken : SyntaxKind
CloseBracketToken = 19,
>CloseBracketToken : SyntaxKind
DotToken = 20,
>DotToken : SyntaxKind
DotDotDotToken = 21,
>DotDotDotToken : SyntaxKind
SemicolonToken = 22,
>SemicolonToken : SyntaxKind
CommaToken = 23,
>CommaToken : SyntaxKind
LessThanToken = 24,
>LessThanToken : SyntaxKind
GreaterThanToken = 25,
>GreaterThanToken : SyntaxKind
LessThanEqualsToken = 26,
>LessThanEqualsToken : SyntaxKind
GreaterThanEqualsToken = 27,
>GreaterThanEqualsToken : SyntaxKind
EqualsEqualsToken = 28,
>EqualsEqualsToken : SyntaxKind
ExclamationEqualsToken = 29,
>ExclamationEqualsToken : SyntaxKind
EqualsEqualsEqualsToken = 30,
>EqualsEqualsEqualsToken : SyntaxKind
ExclamationEqualsEqualsToken = 31,
>ExclamationEqualsEqualsToken : SyntaxKind
EqualsGreaterThanToken = 32,
>EqualsGreaterThanToken : SyntaxKind
PlusToken = 33,
>PlusToken : SyntaxKind
MinusToken = 34,
>MinusToken : SyntaxKind
AsteriskToken = 35,
>AsteriskToken : SyntaxKind
SlashToken = 36,
>SlashToken : SyntaxKind
PercentToken = 37,
>PercentToken : SyntaxKind
PlusPlusToken = 38,
>PlusPlusToken : SyntaxKind
MinusMinusToken = 39,
>MinusMinusToken : SyntaxKind
LessThanLessThanToken = 40,
>LessThanLessThanToken : SyntaxKind
GreaterThanGreaterThanToken = 41,
>GreaterThanGreaterThanToken : SyntaxKind
GreaterThanGreaterThanGreaterThanToken = 42,
>GreaterThanGreaterThanGreaterThanToken : SyntaxKind
AmpersandToken = 43,
>AmpersandToken : SyntaxKind
BarToken = 44,
>BarToken : SyntaxKind
CaretToken = 45,
>CaretToken : SyntaxKind
ExclamationToken = 46,
>ExclamationToken : SyntaxKind
TildeToken = 47,
>TildeToken : SyntaxKind
AmpersandAmpersandToken = 48,
>AmpersandAmpersandToken : SyntaxKind
BarBarToken = 49,
>BarBarToken : SyntaxKind
QuestionToken = 50,
>QuestionToken : SyntaxKind
ColonToken = 51,
>ColonToken : SyntaxKind
AtToken = 52,
>AtToken : SyntaxKind
EqualsToken = 53,
>EqualsToken : SyntaxKind
PlusEqualsToken = 54,
>PlusEqualsToken : SyntaxKind
MinusEqualsToken = 55,
>MinusEqualsToken : SyntaxKind
AsteriskEqualsToken = 56,
>AsteriskEqualsToken : SyntaxKind
SlashEqualsToken = 57,
>SlashEqualsToken : SyntaxKind
PercentEqualsToken = 58,
>PercentEqualsToken : SyntaxKind
LessThanLessThanEqualsToken = 59,
>LessThanLessThanEqualsToken : SyntaxKind
GreaterThanGreaterThanEqualsToken = 60,
>GreaterThanGreaterThanEqualsToken : SyntaxKind
GreaterThanGreaterThanGreaterThanEqualsToken = 61,
>GreaterThanGreaterThanGreaterThanEqualsToken : SyntaxKind
AmpersandEqualsToken = 62,
>AmpersandEqualsToken : SyntaxKind
BarEqualsToken = 63,
>BarEqualsToken : SyntaxKind
CaretEqualsToken = 64,
>CaretEqualsToken : SyntaxKind
Identifier = 65,
>Identifier : SyntaxKind
BreakKeyword = 66,
>BreakKeyword : SyntaxKind
CaseKeyword = 67,
>CaseKeyword : SyntaxKind
CatchKeyword = 68,
>CatchKeyword : SyntaxKind
ClassKeyword = 69,
>ClassKeyword : SyntaxKind
ConstKeyword = 70,
>ConstKeyword : SyntaxKind
ContinueKeyword = 71,
>ContinueKeyword : SyntaxKind
DebuggerKeyword = 72,
>DebuggerKeyword : SyntaxKind
DefaultKeyword = 73,
>DefaultKeyword : SyntaxKind
DeleteKeyword = 74,
>DeleteKeyword : SyntaxKind
DoKeyword = 75,
>DoKeyword : SyntaxKind
ElseKeyword = 76,
>ElseKeyword : SyntaxKind
EnumKeyword = 77,
>EnumKeyword : SyntaxKind
ExportKeyword = 78,
>ExportKeyword : SyntaxKind
ExtendsKeyword = 79,
>ExtendsKeyword : SyntaxKind
FalseKeyword = 80,
>FalseKeyword : SyntaxKind
FinallyKeyword = 81,
>FinallyKeyword : SyntaxKind
ForKeyword = 82,
>ForKeyword : SyntaxKind
FunctionKeyword = 83,
>FunctionKeyword : SyntaxKind
IfKeyword = 84,
>IfKeyword : SyntaxKind
ImportKeyword = 85,
>ImportKeyword : SyntaxKind
InKeyword = 86,
>InKeyword : SyntaxKind
InstanceOfKeyword = 87,
>InstanceOfKeyword : SyntaxKind
NewKeyword = 88,
>NewKeyword : SyntaxKind
NullKeyword = 89,
>NullKeyword : SyntaxKind
ReturnKeyword = 90,
>ReturnKeyword : SyntaxKind
SuperKeyword = 91,
>SuperKeyword : SyntaxKind
SwitchKeyword = 92,
>SwitchKeyword : SyntaxKind
ThisKeyword = 93,
>ThisKeyword : SyntaxKind
ThrowKeyword = 94,
>ThrowKeyword : SyntaxKind
TrueKeyword = 95,
>TrueKeyword : SyntaxKind
TryKeyword = 96,
>TryKeyword : SyntaxKind
TypeOfKeyword = 97,
>TypeOfKeyword : SyntaxKind
VarKeyword = 98,
>VarKeyword : SyntaxKind
VoidKeyword = 99,
>VoidKeyword : SyntaxKind
WhileKeyword = 100,
>WhileKeyword : SyntaxKind
WithKeyword = 101,
>WithKeyword : SyntaxKind
AsKeyword = 102,
>AsKeyword : SyntaxKind
ImplementsKeyword = 103,
>ImplementsKeyword : SyntaxKind
InterfaceKeyword = 104,
>InterfaceKeyword : SyntaxKind
LetKeyword = 105,
>LetKeyword : SyntaxKind
PackageKeyword = 106,
>PackageKeyword : SyntaxKind
PrivateKeyword = 107,
>PrivateKeyword : SyntaxKind
ProtectedKeyword = 108,
>ProtectedKeyword : SyntaxKind
PublicKeyword = 109,
>PublicKeyword : SyntaxKind
StaticKeyword = 110,
>StaticKeyword : SyntaxKind
YieldKeyword = 111,
>YieldKeyword : SyntaxKind
AnyKeyword = 112,
>AnyKeyword : SyntaxKind
BooleanKeyword = 113,
>BooleanKeyword : SyntaxKind
ConstructorKeyword = 114,
>ConstructorKeyword : SyntaxKind
DeclareKeyword = 115,
>DeclareKeyword : SyntaxKind
GetKeyword = 116,
>GetKeyword : SyntaxKind
ModuleKeyword = 117,
>ModuleKeyword : SyntaxKind
RequireKeyword = 118,
>RequireKeyword : SyntaxKind
NumberKeyword = 119,
>NumberKeyword : SyntaxKind
SetKeyword = 120,
>SetKeyword : SyntaxKind
StringKeyword = 121,
>StringKeyword : SyntaxKind
SymbolKeyword = 122,
>SymbolKeyword : SyntaxKind
TypeKeyword = 123,
>TypeKeyword : SyntaxKind
FromKeyword = 124,
>FromKeyword : SyntaxKind
OfKeyword = 125,
>OfKeyword : SyntaxKind
QualifiedName = 126,
>QualifiedName : SyntaxKind
ComputedPropertyName = 127,
>ComputedPropertyName : SyntaxKind
TypeParameter = 128,
>TypeParameter : SyntaxKind
Parameter = 129,
>Parameter : SyntaxKind
Decorator = 130,
>Decorator : SyntaxKind
PropertySignature = 131,
>PropertySignature : SyntaxKind
PropertyDeclaration = 132,
>PropertyDeclaration : SyntaxKind
MethodSignature = 133,
>MethodSignature : SyntaxKind
MethodDeclaration = 134,
>MethodDeclaration : SyntaxKind
Constructor = 135,
>Constructor : SyntaxKind
GetAccessor = 136,
>GetAccessor : SyntaxKind
SetAccessor = 137,
>SetAccessor : SyntaxKind
CallSignature = 138,
>CallSignature : SyntaxKind
ConstructSignature = 139,
>ConstructSignature : SyntaxKind
IndexSignature = 140,
>IndexSignature : SyntaxKind
TypeReference = 141,
>TypeReference : SyntaxKind
FunctionType = 142,
>FunctionType : SyntaxKind
ConstructorType = 143,
>ConstructorType : SyntaxKind
TypeQuery = 144,
>TypeQuery : SyntaxKind
TypeLiteral = 145,
>TypeLiteral : SyntaxKind
ArrayType = 146,
>ArrayType : SyntaxKind
TupleType = 147,
>TupleType : SyntaxKind
UnionType = 148,
>UnionType : SyntaxKind
ParenthesizedType = 149,
>ParenthesizedType : SyntaxKind
ObjectBindingPattern = 150,
>ObjectBindingPattern : SyntaxKind
ArrayBindingPattern = 151,
>ArrayBindingPattern : SyntaxKind
BindingElement = 152,
>BindingElement : SyntaxKind
ArrayLiteralExpression = 153,
>ArrayLiteralExpression : SyntaxKind
ObjectLiteralExpression = 154,
>ObjectLiteralExpression : SyntaxKind
PropertyAccessExpression = 155,
>PropertyAccessExpression : SyntaxKind
ElementAccessExpression = 156,
>ElementAccessExpression : SyntaxKind
CallExpression = 157,
>CallExpression : SyntaxKind
NewExpression = 158,
>NewExpression : SyntaxKind
TaggedTemplateExpression = 159,
>TaggedTemplateExpression : SyntaxKind
TypeAssertionExpression = 160,
>TypeAssertionExpression : SyntaxKind
ParenthesizedExpression = 161,
>ParenthesizedExpression : SyntaxKind
FunctionExpression = 162,
>FunctionExpression : SyntaxKind
ArrowFunction = 163,
>ArrowFunction : SyntaxKind
DeleteExpression = 164,
>DeleteExpression : SyntaxKind
TypeOfExpression = 165,
>TypeOfExpression : SyntaxKind
VoidExpression = 166,
>VoidExpression : SyntaxKind
PrefixUnaryExpression = 167,
>PrefixUnaryExpression : SyntaxKind
PostfixUnaryExpression = 168,
>PostfixUnaryExpression : SyntaxKind
BinaryExpression = 169,
>BinaryExpression : SyntaxKind
ConditionalExpression = 170,
>ConditionalExpression : SyntaxKind
TemplateExpression = 171,
>TemplateExpression : SyntaxKind
YieldExpression = 172,
>YieldExpression : SyntaxKind
SpreadElementExpression = 173,
>SpreadElementExpression : SyntaxKind
OmittedExpression = 174,
>OmittedExpression : SyntaxKind
TemplateSpan = 175,
>TemplateSpan : SyntaxKind
HeritageClauseElement = 176,
>HeritageClauseElement : SyntaxKind
Block = 177,
>Block : SyntaxKind
VariableStatement = 178,
>VariableStatement : SyntaxKind
EmptyStatement = 179,
>EmptyStatement : SyntaxKind
ExpressionStatement = 180,
>ExpressionStatement : SyntaxKind
IfStatement = 181,
>IfStatement : SyntaxKind
DoStatement = 182,
>DoStatement : SyntaxKind
WhileStatement = 183,
>WhileStatement : SyntaxKind
ForStatement = 184,
>ForStatement : SyntaxKind
ForInStatement = 185,
>ForInStatement : SyntaxKind
ForOfStatement = 186,
>ForOfStatement : SyntaxKind
ContinueStatement = 187,
>ContinueStatement : SyntaxKind
BreakStatement = 188,
>BreakStatement : SyntaxKind
ReturnStatement = 189,
>ReturnStatement : SyntaxKind
WithStatement = 190,
>WithStatement : SyntaxKind
SwitchStatement = 191,
>SwitchStatement : SyntaxKind
LabeledStatement = 192,
>LabeledStatement : SyntaxKind
ThrowStatement = 193,
>ThrowStatement : SyntaxKind
TryStatement = 194,
>TryStatement : SyntaxKind
DebuggerStatement = 195,
>DebuggerStatement : SyntaxKind
VariableDeclaration = 196,
>VariableDeclaration : SyntaxKind
VariableDeclarationList = 197,
>VariableDeclarationList : SyntaxKind
FunctionDeclaration = 198,
>FunctionDeclaration : SyntaxKind
ClassDeclaration = 199,
>ClassDeclaration : SyntaxKind
InterfaceDeclaration = 200,
>InterfaceDeclaration : SyntaxKind
TypeAliasDeclaration = 201,
>TypeAliasDeclaration : SyntaxKind
EnumDeclaration = 202,
>EnumDeclaration : SyntaxKind
ModuleDeclaration = 203,
>ModuleDeclaration : SyntaxKind
ModuleBlock = 204,
>ModuleBlock : SyntaxKind
CaseBlock = 205,
>CaseBlock : SyntaxKind
ImportEqualsDeclaration = 206,
>ImportEqualsDeclaration : SyntaxKind
ImportDeclaration = 207,
>ImportDeclaration : SyntaxKind
ImportClause = 208,
>ImportClause : SyntaxKind
NamespaceImport = 209,
>NamespaceImport : SyntaxKind
NamedImports = 210,
>NamedImports : SyntaxKind
ImportSpecifier = 211,
>ImportSpecifier : SyntaxKind
ExportAssignment = 212,
>ExportAssignment : SyntaxKind
ExportDeclaration = 213,
>ExportDeclaration : SyntaxKind
NamedExports = 214,
>NamedExports : SyntaxKind
ExportSpecifier = 215,
>ExportSpecifier : SyntaxKind
MissingDeclaration = 216,
>MissingDeclaration : SyntaxKind
ExternalModuleReference = 217,
>ExternalModuleReference : SyntaxKind
CaseClause = 218,
>CaseClause : SyntaxKind
DefaultClause = 219,
>DefaultClause : SyntaxKind
HeritageClause = 220,
>HeritageClause : SyntaxKind
CatchClause = 221,
>CatchClause : SyntaxKind
PropertyAssignment = 222,
>PropertyAssignment : SyntaxKind
ShorthandPropertyAssignment = 223,
>ShorthandPropertyAssignment : SyntaxKind
EnumMember = 224,
>EnumMember : SyntaxKind
SourceFile = 225,
>SourceFile : SyntaxKind
SyntaxList = 226,
>SyntaxList : SyntaxKind
Count = 227,
>Count : SyntaxKind
FirstAssignment = 53,
>FirstAssignment : SyntaxKind
LastAssignment = 64,
>LastAssignment : SyntaxKind
FirstReservedWord = 66,
>FirstReservedWord : SyntaxKind
LastReservedWord = 101,
>LastReservedWord : SyntaxKind
FirstKeyword = 66,
>FirstKeyword : SyntaxKind
LastKeyword = 125,
>LastKeyword : SyntaxKind
FirstFutureReservedWord = 103,
>FirstFutureReservedWord : SyntaxKind
LastFutureReservedWord = 111,
>LastFutureReservedWord : SyntaxKind
FirstTypeNode = 141,
>FirstTypeNode : SyntaxKind
LastTypeNode = 149,
>LastTypeNode : SyntaxKind
FirstPunctuation = 14,
>FirstPunctuation : SyntaxKind
LastPunctuation = 64,
>LastPunctuation : SyntaxKind
FirstToken = 0,
>FirstToken : SyntaxKind
LastToken = 125,
>LastToken : SyntaxKind
FirstTriviaToken = 2,
>FirstTriviaToken : SyntaxKind
LastTriviaToken = 6,
>LastTriviaToken : SyntaxKind
FirstLiteralToken = 7,
>FirstLiteralToken : SyntaxKind
LastLiteralToken = 10,
>LastLiteralToken : SyntaxKind
FirstTemplateToken = 10,
>FirstTemplateToken : SyntaxKind
LastTemplateToken = 13,
>LastTemplateToken : SyntaxKind
FirstBinaryOperator = 24,
>FirstBinaryOperator : SyntaxKind
LastBinaryOperator = 64,
>LastBinaryOperator : SyntaxKind
FirstNode = 126,
>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
Default = 256,
>Default : NodeFlags
MultiLine = 512,
>MultiLine : NodeFlags
Synthetic = 1024,
>Synthetic : NodeFlags
DeclarationFile = 2048,
>DeclarationFile : NodeFlags
Let = 4096,
>Let : NodeFlags
Const = 8192,
>Const : NodeFlags
OctalLiteral = 16384,
>OctalLiteral : NodeFlags
ExportContext = 32768,
>ExportContext : NodeFlags
Modifier = 499,
>Modifier : NodeFlags
AccessibilityModifier = 112,
>AccessibilityModifier : NodeFlags
BlockScoped = 12288,
>BlockScoped : NodeFlags
}
const enum ParserContextFlags {
>ParserContextFlags : ParserContextFlags
StrictMode = 1,
>StrictMode : ParserContextFlags
DisallowIn = 2,
>DisallowIn : ParserContextFlags
Yield = 4,
>Yield : ParserContextFlags
GeneratorParameter = 8,
>GeneratorParameter : ParserContextFlags
Decorator = 16,
>Decorator : ParserContextFlags
ThisNodeHasError = 32,
>ThisNodeHasError : ParserContextFlags
ParserGeneratedFlags = 63,
>ParserGeneratedFlags : ParserContextFlags
ThisNodeOrAnySubNodesHasError = 64,
>ThisNodeOrAnySubNodesHasError : ParserContextFlags
HasAggregatedChildData = 128,
>HasAggregatedChildData : ParserContextFlags
}
const enum RelationComparisonResult {
>RelationComparisonResult : RelationComparisonResult
Succeeded = 1,
>Succeeded : RelationComparisonResult
Failed = 2,
>Failed : RelationComparisonResult
FailedAndReported = 3,
>FailedAndReported : RelationComparisonResult
}
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
decorators?: NodeArray<Decorator>;
>decorators : NodeArray<Decorator>
>NodeArray : NodeArray<T>
>Decorator : Decorator
modifiers?: ModifiersArray;
>modifiers : ModifiersArray
>ModifiersArray : ModifiersArray
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
}
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 | BindingPattern;
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
>Identifier : Identifier
>LiteralExpression : LiteralExpression
>ComputedPropertyName : ComputedPropertyName
>BindingPattern : BindingPattern
interface Declaration extends Node {
>Declaration : Declaration
>Node : Node
_declarationBrand: any;
>_declarationBrand : any
name?: DeclarationName;
>name : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
}
interface ComputedPropertyName extends Node {
>ComputedPropertyName : ComputedPropertyName
>Node : Node
expression: Expression;
>expression : Expression
>Expression : Expression
}
interface Decorator extends Node {
>Decorator : Decorator
>Node : Node
expression: LeftHandSideExpression;
>expression : LeftHandSideExpression
>LeftHandSideExpression : LeftHandSideExpression
}
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
parent?: VariableDeclarationList;
>parent : VariableDeclarationList
>VariableDeclarationList : VariableDeclarationList
name: Identifier | BindingPattern;
>name : Identifier | BindingPattern
>Identifier : Identifier
>BindingPattern : BindingPattern
type?: TypeNode;
>type : TypeNode
>TypeNode : TypeNode
initializer?: Expression;
>initializer : Expression
>Expression : Expression
}
interface VariableDeclarationList extends Node {
>VariableDeclarationList : VariableDeclarationList
>Node : Node
declarations: NodeArray<VariableDeclaration>;
>declarations : NodeArray<VariableDeclaration>
>NodeArray : NodeArray<T>
>VariableDeclaration : VariableDeclaration
}
interface ParameterDeclaration extends Declaration {
>ParameterDeclaration : ParameterDeclaration
>Declaration : Declaration
dotDotDotToken?: Node;
>dotDotDotToken : Node
>Node : Node
name: Identifier | BindingPattern;
>name : Identifier | BindingPattern
>Identifier : Identifier
>BindingPattern : BindingPattern
questionToken?: Node;
>questionToken : Node
>Node : Node
type?: TypeNode;
>type : TypeNode
>TypeNode : TypeNode
initializer?: Expression;
>initializer : Expression
>Expression : Expression
}
interface BindingElement extends Declaration {
>BindingElement : BindingElement
>Declaration : Declaration
propertyName?: Identifier;
>propertyName : Identifier
>Identifier : Identifier
dotDotDotToken?: Node;
>dotDotDotToken : Node
>Node : Node
name: Identifier | BindingPattern;
>name : Identifier | BindingPattern
>Identifier : Identifier
>BindingPattern : BindingPattern
initializer?: Expression;
>initializer : Expression
>Expression : Expression
}
interface PropertyDeclaration extends Declaration, ClassElement {
>PropertyDeclaration : PropertyDeclaration
>Declaration : Declaration
>ClassElement : ClassElement
name: DeclarationName;
>name : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
questionToken?: Node;
>questionToken : Node
>Node : Node
type?: TypeNode;
>type : TypeNode
>TypeNode : TypeNode
initializer?: Expression;
>initializer : Expression
>Expression : Expression
}
interface ObjectLiteralElement extends Declaration {
>ObjectLiteralElement : ObjectLiteralElement
>Declaration : Declaration
_objectLiteralBrandBrand: any;
>_objectLiteralBrandBrand : any
}
interface PropertyAssignment extends ObjectLiteralElement {
>PropertyAssignment : PropertyAssignment
>ObjectLiteralElement : ObjectLiteralElement
_propertyAssignmentBrand: any;
>_propertyAssignmentBrand : any
name: DeclarationName;
>name : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
questionToken?: Node;
>questionToken : Node
>Node : Node
initializer: Expression;
>initializer : Expression
>Expression : Expression
}
interface ShorthandPropertyAssignment extends ObjectLiteralElement {
>ShorthandPropertyAssignment : ShorthandPropertyAssignment
>ObjectLiteralElement : ObjectLiteralElement
name: Identifier;
>name : Identifier
>Identifier : Identifier
questionToken?: Node;
>questionToken : Node
>Node : Node
}
interface VariableLikeDeclaration extends Declaration {
>VariableLikeDeclaration : VariableLikeDeclaration
>Declaration : Declaration
propertyName?: Identifier;
>propertyName : Identifier
>Identifier : Identifier
dotDotDotToken?: Node;
>dotDotDotToken : Node
>Node : Node
name: DeclarationName;
>name : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
questionToken?: Node;
>questionToken : Node
>Node : Node
type?: TypeNode;
>type : TypeNode
>TypeNode : TypeNode
initializer?: Expression;
>initializer : Expression
>Expression : Expression
}
interface BindingPattern extends Node {
>BindingPattern : BindingPattern
>Node : Node
elements: NodeArray<BindingElement>;
>elements : NodeArray<BindingElement>
>NodeArray : NodeArray<T>
>BindingElement : BindingElement
}
/**
* 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 StringLiteralTypeNode extends LiteralExpression, TypeNode {
>StringLiteralTypeNode : StringLiteralTypeNode
>LiteralExpression : LiteralExpression
>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
operatorToken: Node;
>operatorToken : Node
>Node : Node
right: Expression;
>right : Expression
>Expression : Expression
}
interface ConditionalExpression extends Expression {
>ConditionalExpression : ConditionalExpression
>Expression : Expression
condition: Expression;
>condition : Expression
>Expression : Expression
questionToken: Node;
>questionToken : Node
>Node : Node
whenTrue: Expression;
>whenTrue : Expression
>Expression : Expression
colonToken: Node;
>colonToken : Node
>Node : Node
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 ArrowFunction extends Expression, FunctionLikeDeclaration {
>ArrowFunction : ArrowFunction
>Expression : Expression
>FunctionLikeDeclaration : FunctionLikeDeclaration
equalsGreaterThanToken: Node;
>equalsGreaterThanToken : Node
>Node : Node
}
interface LiteralExpression extends PrimaryExpression {
>LiteralExpression : LiteralExpression
>PrimaryExpression : PrimaryExpression
text: string;
>text : string
isUnterminated?: boolean;
>isUnterminated : boolean
hasExtendedUnicodeEscape?: boolean;
>hasExtendedUnicodeEscape : 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 SpreadElementExpression extends Expression {
>SpreadElementExpression : SpreadElementExpression
>Expression : Expression
expression: Expression;
>expression : Expression
>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
dotToken: Node;
>dotToken : Node
>Node : Node
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 HeritageClauseElement extends Node {
>HeritageClauseElement : HeritageClauseElement
>Node : Node
expression: LeftHandSideExpression;
>expression : LeftHandSideExpression
>LeftHandSideExpression : LeftHandSideExpression
typeArguments?: NodeArray<TypeNode>;
>typeArguments : NodeArray<TypeNode>
>NodeArray : NodeArray<T>
>TypeNode : TypeNode
}
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
declarationList: VariableDeclarationList;
>declarationList : VariableDeclarationList
>VariableDeclarationList : VariableDeclarationList
}
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
initializer?: VariableDeclarationList | Expression;
>initializer : Expression | VariableDeclarationList
>VariableDeclarationList : VariableDeclarationList
>Expression : Expression
condition?: Expression;
>condition : Expression
>Expression : Expression
iterator?: Expression;
>iterator : Expression
>Expression : Expression
}
interface ForInStatement extends IterationStatement {
>ForInStatement : ForInStatement
>IterationStatement : IterationStatement
initializer: VariableDeclarationList | Expression;
>initializer : Expression | VariableDeclarationList
>VariableDeclarationList : VariableDeclarationList
>Expression : Expression
expression: Expression;
>expression : Expression
>Expression : Expression
}
interface ForOfStatement extends IterationStatement {
>ForOfStatement : ForOfStatement
>IterationStatement : IterationStatement
initializer: VariableDeclarationList | Expression;
>initializer : Expression | VariableDeclarationList
>VariableDeclarationList : VariableDeclarationList
>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
caseBlock: CaseBlock;
>caseBlock : CaseBlock
>CaseBlock : CaseBlock
}
interface CaseBlock extends Node {
>CaseBlock : CaseBlock
>Node : Node
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 Node {
>CatchClause : CatchClause
>Node : Node
variableDeclaration: VariableDeclaration;
>variableDeclaration : VariableDeclaration
>VariableDeclaration : VariableDeclaration
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<HeritageClauseElement>;
>types : NodeArray<HeritageClauseElement>
>NodeArray : NodeArray<T>
>HeritageClauseElement : HeritageClauseElement
}
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 | BindingPattern
>DeclarationName : Identifier | LiteralExpression | ComputedPropertyName | BindingPattern
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 ImportEqualsDeclaration extends Declaration, ModuleElement {
>ImportEqualsDeclaration : ImportEqualsDeclaration
>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 ImportDeclaration extends Statement, ModuleElement {
>ImportDeclaration : ImportDeclaration
>Statement : Statement
>ModuleElement : ModuleElement
importClause?: ImportClause;
>importClause : ImportClause
>ImportClause : ImportClause
moduleSpecifier: Expression;
>moduleSpecifier : Expression
>Expression : Expression
}
interface ImportClause extends Declaration {
>ImportClause : ImportClause
>Declaration : Declaration
name?: Identifier;
>name : Identifier
>Identifier : Identifier
namedBindings?: NamespaceImport | NamedImports;
>namedBindings : NamespaceImport | NamedImportsOrExports
>NamespaceImport : NamespaceImport
>NamedImports : NamedImportsOrExports
}
interface NamespaceImport extends Declaration {
>NamespaceImport : NamespaceImport
>Declaration : Declaration
name: Identifier;
>name : Identifier
>Identifier : Identifier
}
interface ExportDeclaration extends Declaration, ModuleElement {
>ExportDeclaration : ExportDeclaration
>Declaration : Declaration
>ModuleElement : ModuleElement
exportClause?: NamedExports;
>exportClause : NamedImportsOrExports
>NamedExports : NamedImportsOrExports
moduleSpecifier?: Expression;
>moduleSpecifier : Expression
>Expression : Expression
}
interface NamedImportsOrExports extends Node {
>NamedImportsOrExports : NamedImportsOrExports
>Node : Node
elements: NodeArray<ImportOrExportSpecifier>;
>elements : NodeArray<ImportOrExportSpecifier>
>NodeArray : NodeArray<T>
>ImportOrExportSpecifier : ImportOrExportSpecifier
}
type NamedImports = NamedImportsOrExports;
>NamedImports : NamedImportsOrExports
>NamedImportsOrExports : NamedImportsOrExports
type NamedExports = NamedImportsOrExports;
>NamedExports : NamedImportsOrExports
>NamedImportsOrExports : NamedImportsOrExports
interface ImportOrExportSpecifier extends Declaration {
>ImportOrExportSpecifier : ImportOrExportSpecifier
>Declaration : Declaration
propertyName?: Identifier;
>propertyName : Identifier
>Identifier : Identifier
name: Identifier;
>name : Identifier
>Identifier : Identifier
}
type ImportSpecifier = ImportOrExportSpecifier;
>ImportSpecifier : ImportOrExportSpecifier
>ImportOrExportSpecifier : ImportOrExportSpecifier
type ExportSpecifier = ImportOrExportSpecifier;
>ExportSpecifier : ImportOrExportSpecifier
>ImportOrExportSpecifier : ImportOrExportSpecifier
interface ExportAssignment extends Declaration, ModuleElement {
>ExportAssignment : ExportAssignment
>Declaration : Declaration
>ModuleElement : ModuleElement
isExportEquals?: boolean;
>isExportEquals : boolean
expression?: Expression;
>expression : Expression
>Expression : Expression
type?: TypeNode;
>type : TypeNode
>TypeNode : TypeNode
}
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
amdDependencies: {
>amdDependencies : { path: string; name: string; }[]
path: string;
>path : string
name: string;
>name : string
}[];
amdModuleName: string;
>amdModuleName : string
referencedFiles: FileReference[];
>referencedFiles : FileReference[]
>FileReference : FileReference
hasNoDefaultLib: boolean;
>hasNoDefaultLib : boolean
externalModuleIndicator: Node;
>externalModuleIndicator : Node
>Node : Node
languageVersion: ScriptTarget;
>languageVersion : ScriptTarget
>ScriptTarget : ScriptTarget
identifiers: Map<string>;
>identifiers : Map<string>
>Map : Map<T>
}
interface ScriptReferenceHost {
>ScriptReferenceHost : ScriptReferenceHost
getCompilerOptions(): CompilerOptions;
>getCompilerOptions : () => CompilerOptions
>CompilerOptions : CompilerOptions
getSourceFile(fileName: string): SourceFile;
>getSourceFile : (fileName: string) => SourceFile
>fileName : string
>SourceFile : SourceFile
getCurrentDirectory(): string;
>getCurrentDirectory : () => string
}
interface WriteFileCallback {
>WriteFileCallback : WriteFileCallback
(fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void): void;
>fileName : string
>data : string
>writeByteOrderMark : boolean
>onError : (message: string) => void
>message : string
}
interface Program extends ScriptReferenceHost {
>Program : Program
>ScriptReferenceHost : ScriptReferenceHost
getSourceFiles(): SourceFile[];
>getSourceFiles : () => SourceFile[]
>SourceFile : SourceFile
/**
* Emits the JavaScript and declaration files. If targetSourceFile is not specified, then
* the JavaScript and declaration files will be produced for all the files in this program.
* If targetSourceFile is specified, then only the JavaScript and declaration for that
* specific file will be generated.
*
* If writeFile is not specified then the writeFile callback from the compiler host will be
* used for writing the JavaScript and declaration files. Otherwise, the writeFile parameter
* will be invoked when writing the JavaScript and declaration files.
*/
emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback): EmitResult;
>emit : (targetSourceFile?: SourceFile, writeFile?: WriteFileCallback) => EmitResult
>targetSourceFile : SourceFile
>SourceFile : SourceFile
>writeFile : WriteFileCallback
>WriteFileCallback : WriteFileCallback
>EmitResult : EmitResult
getSyntacticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
>getSyntacticDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
>sourceFile : SourceFile
>SourceFile : SourceFile
>Diagnostic : Diagnostic
getGlobalDiagnostics(): Diagnostic[];
>getGlobalDiagnostics : () => Diagnostic[]
>Diagnostic : Diagnostic
getSemanticDiagnostics(sourceFile?: SourceFile): Diagnostic[];
>getSemanticDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
>sourceFile : SourceFile
>SourceFile : SourceFile
>Diagnostic : Diagnostic
getDeclarationDiagnostics(sourceFile?: SourceFile): Diagnostic[];
>getDeclarationDiagnostics : (sourceFile?: SourceFile) => Diagnostic[]
>sourceFile : SourceFile
>SourceFile : SourceFile
>Diagnostic : Diagnostic
getTypeChecker(): TypeChecker;
>getTypeChecker : () => TypeChecker
>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 ExitStatus {
>ExitStatus : ExitStatus
Success = 0,
>Success : ExitStatus
DiagnosticsPresent_OutputsSkipped = 1,
>DiagnosticsPresent_OutputsSkipped : ExitStatus
DiagnosticsPresent_OutputsGenerated = 2,
>DiagnosticsPresent_OutputsGenerated : ExitStatus
}
interface EmitResult {
>EmitResult : EmitResult
emitSkipped: boolean;
>emitSkipped : boolean
diagnostics: Diagnostic[];
>diagnostics : Diagnostic[]
>Diagnostic : Diagnostic
sourceMaps: SourceMapData[];
>sourceMaps : SourceMapData[]
>SourceMapData : SourceMapData
}
interface TypeCheckerHost {
>TypeCheckerHost : TypeCheckerHost
getCompilerOptions(): CompilerOptions;
>getCompilerOptions : () => CompilerOptions
>CompilerOptions : CompilerOptions
getSourceFiles(): SourceFile[];
>getSourceFiles : () => SourceFile[]
>SourceFile : SourceFile
getSourceFile(fileName: string): SourceFile;
>getSourceFile : (fileName: string) => SourceFile
>fileName : string
>SourceFile : SourceFile
}
interface TypeChecker {
>TypeChecker : TypeChecker
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
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression | EnumMember) => number
>node : PropertyAccessExpression | ElementAccessExpression | EnumMember
>EnumMember : EnumMember
>PropertyAccessExpression : PropertyAccessExpression
>ElementAccessExpression : ElementAccessExpression
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
getExportsOfExternalModule(node: ImportDeclaration): Symbol[];
>getExportsOfExternalModule : (node: ImportDeclaration) => Symbol[]
>node : ImportDeclaration
>ImportDeclaration : ImportDeclaration
>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
UseFullyQualifiedType = 128,
>UseFullyQualifiedType : 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
}
type AnyImportSyntax = ImportDeclaration | ImportEqualsDeclaration;
>AnyImportSyntax : ImportEqualsDeclaration | ImportDeclaration
>ImportDeclaration : ImportDeclaration
>ImportEqualsDeclaration : ImportEqualsDeclaration
interface SymbolVisibilityResult {
>SymbolVisibilityResult : SymbolVisibilityResult
accessibility: SymbolAccessibility;
>accessibility : SymbolAccessibility
>SymbolAccessibility : SymbolAccessibility
aliasesToMakeVisible?: AnyImportSyntax[];
>aliasesToMakeVisible : (ImportEqualsDeclaration | ImportDeclaration)[]
>AnyImportSyntax : ImportEqualsDeclaration | 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
hasGlobalName(name: string): boolean;
>hasGlobalName : (name: string) => boolean
>name : string
getExpressionNameSubstitution(node: Identifier, getGeneratedNameForNode: (node: Node) => string): string;
>getExpressionNameSubstitution : (node: Identifier, getGeneratedNameForNode: (node: Node) => string) => string
>node : Identifier
>Identifier : Identifier
>getGeneratedNameForNode : (node: Node) => string
>node : Node
>Node : Node
isValueAliasDeclaration(node: Node): boolean;
>isValueAliasDeclaration : (node: Node) => boolean
>node : Node
>Node : Node
isReferencedAliasDeclaration(node: Node, checkChildren?: boolean): boolean;
>isReferencedAliasDeclaration : (node: Node, checkChildren?: boolean) => boolean
>node : Node
>Node : Node
>checkChildren : boolean
isTopLevelValueImportEqualsWithEntityName(node: ImportEqualsDeclaration): boolean;
>isTopLevelValueImportEqualsWithEntityName : (node: ImportEqualsDeclaration) => boolean
>node : ImportEqualsDeclaration
>ImportEqualsDeclaration : ImportEqualsDeclaration
getNodeCheckFlags(node: Node): NodeCheckFlags;
>getNodeCheckFlags : (node: Node) => NodeCheckFlags
>node : Node
>Node : Node
>NodeCheckFlags : NodeCheckFlags
isDeclarationVisible(node: Declaration): boolean;
>isDeclarationVisible : (node: Declaration) => boolean
>node : Declaration
>Declaration : Declaration
collectLinkedAliases(node: Identifier): Node[];
>collectLinkedAliases : (node: Identifier) => Node[]
>node : Identifier
>Identifier : Identifier
>Node : Node
isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
>isImplementationOfOverload : (node: FunctionLikeDeclaration) => boolean
>node : FunctionLikeDeclaration
>FunctionLikeDeclaration : FunctionLikeDeclaration
writeTypeOfDeclaration(declaration: AccessorDeclaration | VariableLikeDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
>writeTypeOfDeclaration : (declaration: VariableLikeDeclaration | AccessorDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
>declaration : VariableLikeDeclaration | AccessorDeclaration
>AccessorDeclaration : AccessorDeclaration
>VariableLikeDeclaration : VariableLikeDeclaration
>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
writeTypeOfExpression(expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter): void;
>writeTypeOfExpression : (expr: Expression, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: SymbolWriter) => void
>expr : Expression
>Expression : Expression
>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 | Expression, enclosingDeclaration: Node): SymbolVisibilityResult;
>isEntityNameVisible : (entityName: Identifier | Expression | QualifiedName, enclosingDeclaration: Node) => SymbolVisibilityResult
>entityName : Identifier | Expression | QualifiedName
>EntityName : Identifier | QualifiedName
>Expression : Expression
>enclosingDeclaration : Node
>Node : Node
>SymbolVisibilityResult : SymbolVisibilityResult
getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
>getConstantValue : (node: PropertyAccessExpression | ElementAccessExpression | EnumMember) => number
>node : PropertyAccessExpression | ElementAccessExpression | EnumMember
>EnumMember : EnumMember
>PropertyAccessExpression : PropertyAccessExpression
>ElementAccessExpression : ElementAccessExpression
resolvesToSomeValue(location: Node, name: string): boolean;
>resolvesToSomeValue : (location: Node, name: string) => boolean
>location : Node
>Node : Node
>name : string
getBlockScopedVariableId(node: Identifier): number;
>getBlockScopedVariableId : (node: Identifier) => number
>node : Identifier
>Identifier : Identifier
}
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
Signature = 131072,
>Signature : SymbolFlags
TypeParameter = 262144,
>TypeParameter : SymbolFlags
TypeAlias = 524288,
>TypeAlias : SymbolFlags
ExportValue = 1048576,
>ExportValue : SymbolFlags
ExportType = 2097152,
>ExportType : SymbolFlags
ExportNamespace = 4194304,
>ExportNamespace : SymbolFlags
Alias = 8388608,
>Alias : SymbolFlags
Instantiated = 16777216,
>Instantiated : SymbolFlags
Merged = 33554432,
>Merged : SymbolFlags
Transient = 67108864,
>Transient : SymbolFlags
Prototype = 134217728,
>Prototype : SymbolFlags
UnionProperty = 268435456,
>UnionProperty : SymbolFlags
Optional = 536870912,
>Optional : SymbolFlags
ExportStar = 1073741824,
>ExportStar : SymbolFlags
Enum = 384,
>Enum : SymbolFlags
Variable = 3,
>Variable : SymbolFlags
Value = 107455,
>Value : SymbolFlags
Type = 793056,
>Type : SymbolFlags
Namespace = 1536,
>Namespace : SymbolFlags
Module = 1536,
>Module : SymbolFlags
Accessor = 98304,
>Accessor : 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 = 899583,
>ClassExcludes : SymbolFlags
InterfaceExcludes = 792992,
>InterfaceExcludes : SymbolFlags
RegularEnumExcludes = 899327,
>RegularEnumExcludes : SymbolFlags
ConstEnumExcludes = 899967,
>ConstEnumExcludes : SymbolFlags
ValueModuleExcludes = 106639,
>ValueModuleExcludes : SymbolFlags
NamespaceModuleExcludes = 0,
>NamespaceModuleExcludes : SymbolFlags
MethodExcludes = 99263,
>MethodExcludes : SymbolFlags
GetAccessorExcludes = 41919,
>GetAccessorExcludes : SymbolFlags
SetAccessorExcludes = 74687,
>SetAccessorExcludes : SymbolFlags
TypeParameterExcludes = 530912,
>TypeParameterExcludes : SymbolFlags
TypeAliasExcludes = 793056,
>TypeAliasExcludes : SymbolFlags
AliasExcludes = 8388608,
>AliasExcludes : SymbolFlags
ModuleMember = 8914931,
>ModuleMember : SymbolFlags
ExportHasLocal = 944,
>ExportHasLocal : SymbolFlags
HasLocals = 255504,
>HasLocals : SymbolFlags
HasExports = 1952,
>HasExports : SymbolFlags
HasMembers = 6240,
>HasMembers : SymbolFlags
IsContainer = 262128,
>IsContainer : SymbolFlags
PropertyOrAccessor = 98308,
>PropertyOrAccessor : SymbolFlags
Export = 7340032,
>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
unionType?: UnionType;
>unionType : UnionType
>UnionType : UnionType
resolvedExports?: SymbolTable;
>resolvedExports : SymbolTable
>SymbolTable : SymbolTable
exportsChecked?: boolean;
>exportsChecked : boolean
}
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
BlockScopedBindingInLoop = 256,
>BlockScopedBindingInLoop : NodeCheckFlags
EmitDecorate = 512,
>EmitDecorate : 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
generatedName?: string;
>generatedName : string
generatedNames?: Map<string>;
>generatedNames : Map<string>
>Map : Map<T>
assignmentChecks?: Map<boolean>;
>assignmentChecks : Map<boolean>
>Map : Map<T>
hasReportedStatementInAmbientContext?: boolean;
>hasReportedStatementInAmbientContext : boolean
importOnRightSide?: Symbol;
>importOnRightSide : Symbol
>Symbol : Symbol
}
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
ObjectLiteral = 131072,
>ObjectLiteral : TypeFlags
ContainsUndefinedOrNull = 262144,
>ContainsUndefinedOrNull : TypeFlags
ContainsObjectLiteral = 524288,
>ContainsObjectLiteral : TypeFlags
ESSymbol = 1048576,
>ESSymbol : TypeFlags
Intrinsic = 1048703,
>Intrinsic : TypeFlags
Primitive = 1049086,
>Primitive : TypeFlags
StringLike = 258,
>StringLike : TypeFlags
NumberLike = 132,
>NumberLike : TypeFlags
ObjectType = 48128,
>ObjectType : TypeFlags
RequiresWidening = 786432,
>RequiresWidening : 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
}
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 DiagnosticMessage {
>DiagnosticMessage : DiagnosticMessage
key: string;
>key : string
category: DiagnosticCategory;
>category : DiagnosticCategory
>DiagnosticCategory : DiagnosticCategory
code: number;
>code : number
}
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 | DiagnosticMessageChain;
>messageText : string | DiagnosticMessageChain
>DiagnosticMessageChain : DiagnosticMessageChain
category: DiagnosticCategory;
>category : DiagnosticCategory
>DiagnosticCategory : DiagnosticCategory
code: number;
>code : number
}
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
listFiles?: boolean;
>listFiles : boolean
locale?: string;
>locale : string
mapRoot?: string;
>mapRoot : string
module?: ModuleKind;
>module : ModuleKind
>ModuleKind : ModuleKind
noEmit?: boolean;
>noEmit : boolean
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
project?: string;
>project : string
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>
isFilePath?: boolean;
>isFilePath : boolean
shortName?: string;
>shortName : string
description?: DiagnosticMessage;
>description : DiagnosticMessage
>DiagnosticMessage : DiagnosticMessage
paramType?: DiagnosticMessage;
>paramType : DiagnosticMessage
>DiagnosticMessage : DiagnosticMessage
error?: DiagnosticMessage;
>error : DiagnosticMessage
>DiagnosticMessage : DiagnosticMessage
experimental?: boolean;
>experimental : boolean
}
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
hash = 35,
>hash : 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: WriteFileCallback;
>writeFile : WriteFileCallback
>WriteFileCallback : WriteFileCallback
getCurrentDirectory(): string;
>getCurrentDirectory : () => string
getCanonicalFileName(fileName: string): string;
>getCanonicalFileName : (fileName: string) => string
>fileName : string
useCaseSensitiveFileNames(): boolean;
>useCaseSensitiveFileNames : () => boolean
getNewLine(): string;
>getNewLine : () => string
}
interface TextSpan {
>TextSpan : TextSpan
start: number;
>start : number
length: number;
>length : number
}
interface TextChangeRange {
>TextChangeRange : TextChangeRange
span: TextSpan;
>span : TextSpan
>TextSpan : TextSpan
newLength: number;
>newLength : number
}
}
declare module "typescript" {
interface ErrorCallback {
>ErrorCallback : ErrorCallback
(message: DiagnosticMessage, length: number): void;
>message : DiagnosticMessage
>DiagnosticMessage : DiagnosticMessage
>length : 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
hasExtendedUnicodeEscape(): boolean;
>hasExtendedUnicodeEscape : () => boolean
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 getPositionOfLineAndCharacter(sourceFile: SourceFile, line: number, character: number): number;
>getPositionOfLineAndCharacter : (sourceFile: SourceFile, line: number, character: number) => number
>sourceFile : SourceFile
>SourceFile : SourceFile
>line : number
>character : number
function computePositionOfLineAndCharacter(lineStarts: number[], line: number, character: number): number;
>computePositionOfLineAndCharacter : (lineStarts: number[], line: number, character: number) => number
>lineStarts : number[]
>line : number
>character : number
function getLineStarts(sourceFile: SourceFile): number[];
>getLineStarts : (sourceFile: SourceFile) => number[]
>sourceFile : SourceFile
>SourceFile : SourceFile
function computeLineAndCharacterOfPosition(lineStarts: number[], position: number): {
>computeLineAndCharacterOfPosition : (lineStarts: number[], position: number) => { line: number; character: number; }
>lineStarts : number[]
>position : number
line: number;
>line : number
character: number;
>character : number
};
function getLineAndCharacterOfPosition(sourceFile: SourceFile, position: number): LineAndCharacter;
>getLineAndCharacterOfPosition : (sourceFile: SourceFile, position: number) => LineAndCharacter
>sourceFile : SourceFile
>SourceFile : SourceFile
>position : number
>LineAndCharacter : LineAndCharacter
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 createNode(kind: SyntaxKind): Node;
>createNode : (kind: SyntaxKind) => Node
>kind : SyntaxKind
>SyntaxKind : SyntaxKind
>Node : Node
function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T;
>forEachChild : <T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T) => T
>T : T
>node : Node
>Node : Node
>cbNode : (node: Node) => T
>node : Node
>Node : Node
>T : T
>cbNodeArray : (nodes: Node[]) => T
>nodes : Node[]
>Node : Node
>T : T
>T : T
function modifierToFlag(token: SyntaxKind): NodeFlags;
>modifierToFlag : (token: SyntaxKind) => NodeFlags
>token : SyntaxKind
>SyntaxKind : SyntaxKind
>NodeFlags : NodeFlags
function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
>updateSourceFile : (sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean) => SourceFile
>sourceFile : SourceFile
>SourceFile : SourceFile
>newText : string
>textChangeRange : TextChangeRange
>TextChangeRange : TextChangeRange
>aggressiveChecks : boolean
>SourceFile : SourceFile
function isEvalOrArgumentsIdentifier(node: Node): boolean;
>isEvalOrArgumentsIdentifier : (node: Node) => boolean
>node : Node
>Node : Node
function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean): SourceFile;
>createSourceFile : (fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean) => SourceFile
>fileName : string
>sourceText : string
>languageVersion : ScriptTarget
>ScriptTarget : ScriptTarget
>setParentNodes : boolean
>SourceFile : SourceFile
function isLeftHandSideExpression(expr: Expression): boolean;
>isLeftHandSideExpression : (expr: Expression) => boolean
>expr : Expression
>Expression : Expression
function isAssignmentOperator(token: SyntaxKind): boolean;
>isAssignmentOperator : (token: SyntaxKind) => boolean
>token : SyntaxKind
>SyntaxKind : SyntaxKind
}
declare module "typescript" {
function createTypeChecker(host: TypeCheckerHost, produceDiagnostics: boolean): TypeChecker;
>createTypeChecker : (host: TypeCheckerHost, produceDiagnostics: boolean) => TypeChecker
>host : TypeCheckerHost
>TypeCheckerHost : TypeCheckerHost
>produceDiagnostics : boolean
>TypeChecker : TypeChecker
}
declare module "typescript" {
/** The version of the TypeScript compiler release */
let version: string;
>version : string
function findConfigFile(searchPath: string): string;
>findConfigFile : (searchPath: string) => string
>searchPath : string
function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
>createCompilerHost : (options: CompilerOptions, setParentNodes?: boolean) => CompilerHost
>options : CompilerOptions
>CompilerOptions : CompilerOptions
>setParentNodes : boolean
>CompilerHost : CompilerHost
function getPreEmitDiagnostics(program: Program): Diagnostic[];
>getPreEmitDiagnostics : (program: Program) => Diagnostic[]
>program : Program
>Program : Program
>Diagnostic : Diagnostic
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
>flattenDiagnosticMessageText : (messageText: string | DiagnosticMessageChain, newLine: string) => string
>messageText : string | DiagnosticMessageChain
>DiagnosticMessageChain : DiagnosticMessageChain
>newLine : string
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" {
/** The version of the language service API */
let 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
getNamedDeclarations(): Declaration[];
>getNamedDeclarations : () => Declaration[]
>Declaration : Declaration
getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
>getLineAndCharacterOfPosition : (pos: number) => LineAndCharacter
>pos : number
>LineAndCharacter : LineAndCharacter
getLineStarts(): number[];
>getLineStarts : () => number[]
getPositionOfLineAndCharacter(line: number, character: number): number;
>getPositionOfLineAndCharacter : (line: number, character: number) => number
>line : number
>character : number
update(newText: string, textChangeRange: TextChangeRange): SourceFile;
>update : (newText: string, textChangeRange: TextChangeRange) => SourceFile
>newText : string
>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
/**
* 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 LanguageServiceHost {
>LanguageServiceHost : LanguageServiceHost
getCompilationSettings(): CompilerOptions;
>getCompilationSettings : () => CompilerOptions
>CompilerOptions : CompilerOptions
getNewLine?(): string;
>getNewLine : () => string
getScriptFileNames(): string[];
>getScriptFileNames : () => string[]
getScriptVersion(fileName: string): string;
>getScriptVersion : (fileName: string) => string
>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
log?(s: string): void;
>log : (s: string) => void
>s : string
trace?(s: string): void;
>trace : (s: string) => void
>s : string
error?(s: string): void;
>error : (s: string) => void
>s : string
}
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
findReferences(fileName: string, position: number): ReferencedSymbol[];
>findReferences : (fileName: string, position: number) => ReferencedSymbol[]
>fileName : string
>position : number
>ReferencedSymbol : ReferencedSymbol
getNavigateToItems(searchValue: string, maxResultCount?: number): NavigateToItem[];
>getNavigateToItems : (searchValue: string, maxResultCount?: number) => NavigateToItem[]
>searchValue : string
>maxResultCount : number
>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
getProgram(): Program;
>getProgram : () => Program
>Program : Program
getSourceFile(fileName: string): SourceFile;
>getSourceFile : (fileName: string) => SourceFile
>fileName : string
>SourceFile : SourceFile
dispose(): void;
>dispose : () => void
}
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
isCaseSensitive: boolean;
>isCaseSensitive : boolean
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
[s: string]: boolean | number | string;
>s : string
}
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
}
interface ReferencedSymbol {
>ReferencedSymbol : ReferencedSymbol
definition: DefinitionInfo;
>definition : DefinitionInfo
>DefinitionInfo : DefinitionInfo
references: ReferenceEntry[];
>references : ReferenceEntry[]
>ReferenceEntry : ReferenceEntry
}
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
isNewIdentifierLocation: boolean;
>isNewIdentifierLocation : 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
emitSkipped: boolean;
>emitSkipped : boolean
}
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
InTemplateHeadOrNoSubstitutionTemplate = 4,
>InTemplateHeadOrNoSubstitutionTemplate : EndOfLineState
InTemplateMiddleOrTail = 5,
>InTemplateMiddleOrTail : EndOfLineState
InTemplateSubstitutionPosition = 6,
>InTemplateSubstitutionPosition : 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
/**
* Gives lexical classifications of tokens on a line without any syntactic context.
* For instance, a token consisting of the text 'string' can be either an identifier
* named 'string' or the keyword 'string', however, because this classifier is not aware,
* it relies on certain heuristics to give acceptable results. For classifications where
* speed trumps accuracy, this function is preferable; however, for true accuracy, the
* syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
* lexical, syntactic, and semantic classifiers may issue the best user experience.
*
* @param text The text of a line to classify.
* @param lexState The state of the lexical classifier at the end of the previous line.
* @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
* If there is no syntactic classifier (syntacticClassifierAbsent=true),
* certain heuristics may be used in its place; however, if there is a
* syntactic classifier (syntacticClassifierAbsent=false), certain
* classifications which may be incorrectly categorized will be given
* back as Identifiers in order to allow the syntactic classifier to
* subsume the classification.
*/
getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
>getClassificationsForLine : (text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean) => ClassificationResult
>text : string
>lexState : EndOfLineState
>EndOfLineState : EndOfLineState
>syntacticClassifierAbsent : boolean
>ClassificationResult : ClassificationResult
}
/**
* The document registry represents a store of SourceFile objects that can be shared between
* multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
* of files in the context.
* SourceFile objects account for most of the memory usage by the language service. Sharing
* the same DocumentRegistry instance between different instances of LanguageService allow
* for more efficient memory utilization since all projects will share at least the library
* file (lib.d.ts).
*
* A more advanced use of the document registry is to serialize sourceFile objects to disk
* and re-hydrate them when needed.
*
* To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
* to all subsequent createLanguageService calls.
*/
interface DocumentRegistry {
>DocumentRegistry : DocumentRegistry
/**
* Request a stored SourceFile with a given fileName and compilationSettings.
* The first call to acquire will call createLanguageServiceSourceFile to generate
* the SourceFile if was not found in the registry.
*
* @param fileName The name of the file requested
* @param compilationSettings Some compilation settings like target affects the
* shape of a the resulting SourceFile. This allows the DocumentRegistry to store
* multiple copies of the same file for different compilation settings.
* @parm scriptSnapshot Text of the file. Only used if the file was not found
* in the registry and a new one was created.
* @parm version Current version of the file. Only used if the file was not found
* in the registry and a new one was created.
*/
acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string): SourceFile;
>acquireDocument : (fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string) => SourceFile
>fileName : string
>compilationSettings : CompilerOptions
>CompilerOptions : CompilerOptions
>scriptSnapshot : IScriptSnapshot
>IScriptSnapshot : IScriptSnapshot
>version : string
>SourceFile : SourceFile
/**
* Request an updated version of an already existing SourceFile with a given fileName
* and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
* to get an updated SourceFile.
*
* @param fileName The name of the file requested
* @param compilationSettings Some compilation settings like target affects the
* shape of a the resulting SourceFile. This allows the DocumentRegistry to store
* multiple copies of the same file for different compilation settings.
* @param scriptSnapshot Text of the file.
* @param version Current version of the file.
*/
updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string): SourceFile;
>updateDocument : (fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string) => SourceFile
>fileName : string
>compilationSettings : CompilerOptions
>CompilerOptions : CompilerOptions
>scriptSnapshot : IScriptSnapshot
>IScriptSnapshot : IScriptSnapshot
>version : string
>SourceFile : SourceFile
/**
* Informs the DocumentRegistry that a file is not needed any longer.
*
* Note: It is not allowed to call release on a SourceFile that was not acquired from
* this registry originally.
*
* @param fileName The name of the file to be released
* @param compilationSettings The compilation settings used to acquire the file
*/
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 createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean): SourceFile;
>createLanguageServiceSourceFile : (fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean) => SourceFile
>fileName : string
>scriptSnapshot : IScriptSnapshot
>IScriptSnapshot : IScriptSnapshot
>scriptTarget : ScriptTarget
>ScriptTarget : ScriptTarget
>version : string
>setNodeParents : boolean
>SourceFile : SourceFile
let disableIncrementalParsing: boolean;
>disableIncrementalParsing : boolean
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
>updateLanguageServiceSourceFile : (sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean) => SourceFile
>sourceFile : SourceFile
>SourceFile : SourceFile
>scriptSnapshot : IScriptSnapshot
>IScriptSnapshot : IScriptSnapshot
>version : string
>textChangeRange : TextChangeRange
>TextChangeRange : TextChangeRange
>aggressiveChecks : boolean
>SourceFile : SourceFile
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(): Classifier;
>createClassifier : () => Classifier
>Classifier : Classifier
/**
* Get the path of the default library file (lib.d.ts) as distributed with the typescript
* node package.
* The functionality is not supported if the ts module is consumed outside of a node module.
*/
function getDefaultLibFilePath(options: CompilerOptions): string;
>getDefaultLibFilePath : (options: CompilerOptions) => string
>options : CompilerOptions
>CompilerOptions : CompilerOptions
}
Reference in a new issue View git blame Copy permalink