get(fileName: string): T;

set(fileName: string, value: T): void;

contains(fileName: string): boolean;

remove(fileName: string): void;

forEachValue(f: (v: T) => void): void;

clear(): void;

Unknown,

EndOfFileToken,

SingleLineCommentTrivia,

MultiLineCommentTrivia,

NewLineTrivia,

WhitespaceTrivia,

// We detect and preserve #! on the first line

ShebangTrivia,

// We detect and provide better error recovery when we encounter a git merge marker. This

// allows us to edit files with git-conflict markers in them in a much more pleasant manner.

ConflictMarkerTrivia,

// Literals

NumericLiteral,

StringLiteral,

RegularExpressionLiteral,

NoSubstitutionTemplateLiteral,

// Pseudo-literals

TemplateHead,

TemplateMiddle,

TemplateTail,

// Punctuation

OpenBraceToken,

CloseBraceToken,

OpenParenToken,

CloseParenToken,

OpenBracketToken,

CloseBracketToken,

DotToken,

DotDotDotToken,

SemicolonToken,

CommaToken,

LessThanToken,

LessThanSlashToken,

GreaterThanToken,

LessThanEqualsToken,

GreaterThanEqualsToken,

EqualsEqualsToken,

ExclamationEqualsToken,

EqualsEqualsEqualsToken,

ExclamationEqualsEqualsToken,

EqualsGreaterThanToken,

PlusToken,

MinusToken,

AsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

SlashEqualsToken,

PercentEqualsToken,

LessThanLessThanEqualsToken,

GreaterThanGreaterThanEqualsToken,

GreaterThanGreaterThanGreaterThanEqualsToken,

AmpersandEqualsToken,

BarEqualsToken,

CaretEqualsToken,

// Identifiers

Identifier,

// Reserved words

BreakKeyword,

CaseKeyword,

CatchKeyword,

ClassKeyword,

ConstKeyword,

ContinueKeyword,

DebuggerKeyword,

DefaultKeyword,

DeleteKeyword,

DoKeyword,

ElseKeyword,

EnumKeyword,

ExportKeyword,

ExtendsKeyword,

FalseKeyword,

FinallyKeyword,

ForKeyword,

FunctionKeyword,

IfKeyword,

ImportKeyword,

InKeyword,

InstanceOfKeyword,

NewKeyword,

NullKeyword,

ReturnKeyword,

SuperKeyword,

SwitchKeyword,

ThisKeyword,

ThrowKeyword,

TrueKeyword,

TryKeyword,

TypeOfKeyword,

VarKeyword,

VoidKeyword,

WhileKeyword,

WithKeyword,

// Strict mode reserved words

ImplementsKeyword,

InterfaceKeyword,

LetKeyword,

PackageKeyword,

PrivateKeyword,

ProtectedKeyword,

PublicKeyword,

StaticKeyword,

YieldKeyword,

// Contextual keywords

AbstractKeyword,

AsKeyword,

AnyKeyword,

AsyncKeyword,

AwaitKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

IsKeyword,

ModuleKeyword,

NamespaceKeyword,

RequireKeyword,

NumberKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

FromKeyword,

OfKeyword, // LastKeyword and LastToken

// Parse tree nodes

// Names

QualifiedName,

ComputedPropertyName,

// Signature elements

TypeParameter,

Parameter,

Decorator,

// TypeMember

PropertySignature,

PropertyDeclaration,

MethodSignature,

MethodDeclaration,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypePredicate,

TypeReference,

FunctionType,

ConstructorType,

TypeQuery,

TypeLiteral,

ArrayType,

TupleType,

UnionType,

IntersectionType,

ParenthesizedType,

// Binding patterns

ObjectBindingPattern,

ArrayBindingPattern,

BindingElement,

// Expression

ArrayLiteralExpression,

ObjectLiteralExpression,

PropertyAccessExpression,

ElementAccessExpression,

CallExpression,

NewExpression,

TaggedTemplateExpression,

TypeAssertionExpression,

ParenthesizedExpression,

FunctionExpression,

ArrowFunction,

DeleteExpression,

TypeOfExpression,

VoidExpression,

AwaitExpression,

PrefixUnaryExpression,

PostfixUnaryExpression,

BinaryExpression,

ConditionalExpression,

TemplateExpression,

YieldExpression,

SpreadElementExpression,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

AsExpression,

// Misc

TemplateSpan,

SemicolonClassElement,

// Element

Block,

VariableStatement,

EmptyStatement,

ExpressionStatement,

IfStatement,

DoStatement,

WhileStatement,

ForStatement,

ForInStatement,

ForOfStatement,

ContinueStatement,

BreakStatement,

ReturnStatement,

WithStatement,

SwitchStatement,

LabeledStatement,

ThrowStatement,

TryStatement,

DebuggerStatement,

VariableDeclaration,

VariableDeclarationList,

FunctionDeclaration,

ClassDeclaration,

InterfaceDeclaration,

TypeAliasDeclaration,

EnumDeclaration,

ModuleDeclaration,

ModuleBlock,

CaseBlock,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// JSX

JsxElement,

JsxSelfClosingElement,

JsxOpeningElement,

JsxText,

JsxClosingElement,

JsxAttribute,

JsxSpreadAttribute,

JsxExpression,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

// JSDoc nodes.

JSDocTypeExpression,

// The * type.

JSDocAllType,

// The ? type.

JSDocUnknownType,

JSDocArrayType,

JSDocUnionType,

JSDocTupleType,

JSDocNullableType,

JSDocNonNullableType,

JSDocRecordType,

JSDocRecordMember,

JSDocTypeReference,

JSDocOptionalType,

JSDocFunctionType,

JSDocVariadicType,

JSDocConstructorType,

JSDocThisType,

JSDocComment,

JSDocTag,

JSDocParameterTag,

JSDocReturnTag,

JSDocTypeTag,

JSDocTemplateTag,

// Synthesized list

SyntaxList,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypeReference,

LastTypeNode = ParenthesizedType,

FirstPunctuation = OpenBraceToken,

LastPunctuation = CaretEqualsToken,

FirstToken = Unknown,

LastToken = LastKeyword,

FirstTriviaToken = SingleLineCommentTrivia,

LastTriviaToken = ConflictMarkerTrivia,

FirstLiteralToken = NumericLiteral,

LastLiteralToken = NoSubstitutionTemplateLiteral,

FirstTemplateToken = NoSubstitutionTemplateLiteral,

LastTemplateToken = TemplateTail,

FirstBinaryOperator = LessThanToken,

LastBinaryOperator = CaretEqualsToken,

FirstNode = QualifiedName,

Export = 0x00000001, // Declarations

Ambient = 0x00000002, // Declarations

Public = 0x00000010, // Property/Method

Private = 0x00000020, // Property/Method

Protected = 0x00000040, // Property/Method

Static = 0x00000080, // Property/Method

Abstract = 0x00000100, // Class/Method/ConstructSignature

Async = 0x00000200, // Property/Method/Function

Default = 0x00000400, // Function/Class (export default declaration)

MultiLine = 0x00000800, // Multi-line array or object literal

Synthetic = 0x00001000, // Synthetic node (for full fidelity)

DeclarationFile = 0x00002000, // Node is a .d.ts file

Let = 0x00004000, // Variable declaration

Const = 0x00008000, // Variable declaration

OctalLiteral = 0x00010000, // Octal numeric literal

Namespace = 0x00020000, // Namespace declaration

ExportContext = 0x00040000, // Export context (initialized by binding)

Modifier = Export | Ambient | Public | Private | Protected | Static | Abstract | Default | Async,

AccessibilityModifier = Public | Private | Protected,

BlockScoped = Let | Const

None = 0,

// If this node was parsed in a context where 'in-expressions' are not allowed.

DisallowIn = 1 << 0,

// If this node was parsed in the 'yield' context created when parsing a generator.

Yield = 1 << 1,

// If this node was parsed as part of a decorator

Decorator = 1 << 2,

// If this node was parsed in the 'await' context created when parsing an async function.

Await = 1 << 3,

// If the parser encountered an error when parsing the code that created this node. Note

// the parser only sets this directly on the node it creates right after encountering the

// error.

ThisNodeHasError = 1 << 4,

// This node was parsed in a JavaScript file and can be processed differently. For example

// its type can be specified usign a JSDoc comment.

JavaScriptFile = 1 << 5,

// Context flags set directly by the parser.

ParserGeneratedFlags = DisallowIn | Yield | Decorator | ThisNodeHasError | Await,

// Exclude these flags when parsing a Type

TypeExcludesFlags = Yield | Await,

// Context flags computed by aggregating child flags upwards.

// Used during incremental parsing to determine if this node or any of its children had an

// error. Computed only once and then cached.

ThisNodeOrAnySubNodesHasError = 1 << 6,

// Used to know if we've computed data from children and cached it in this node.

HasAggregatedChildData = 1 << 7

None = 0,

IntrinsicNamedElement = 1 << 0,

IntrinsicIndexedElement = 1 << 1,

ClassElement = 1 << 2,

UnknownElement = 1 << 3,

IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement

Succeeded = 1, // Should be truthy

Failed = 2,

FailedAndReported = 3

kind: SyntaxKind;

flags: NodeFlags;

// Specific context the parser was in when this node was created. Normally undefined.

// Only set when the parser was in some interesting context (like async/yield).

/* @internal */ parserContextFlags?: ParserContextFlags;

decorators?: NodeArray<Decorator>; // Array of decorators (in document order)

modifiers?: ModifiersArray; // Array of modifiers

/* @internal */ id?: number; // Unique id (used to look up NodeLinks)

parent?: Node; // Parent node (initialized by binding

/* @internal */ jsDocComment?: JSDocComment; // JSDoc for the node, if it has any. Only for .js files.

/* @internal */ symbol?: Symbol; // Symbol declared by node (initialized by binding)

/* @internal */ locals?: SymbolTable; // Locals associated with node (initialized by binding)

/* @internal */ nextContainer?: Node; // Next container in declaration order (initialized by binding)

/* @internal */ localSymbol?: Symbol; // Local symbol declared by node (initialized by binding only for exported nodes)

// Must have same layout as PropertyAccess

left: EntityName;

right: Identifier;

name: Identifier;

constraint?: TypeNode;

// For error recovery purposes.

expression?: Expression;

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

parent?: VariableDeclarationList;

name: Identifier | BindingPattern; // Declared variable name

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

dotDotDotToken?: Node; // Present on rest parameter

name: Identifier | BindingPattern; // Declared parameter name

questionToken?: Node; // Present on optional parameter

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

propertyName?: Identifier; // Binding property name (in object binding pattern)

dotDotDotToken?: Node; // Present on rest binding element

name: Identifier | BindingPattern; // Declared binding element name

initializer?: Expression; // Optional initializer

name: DeclarationName; // Declared property name

questionToken?: Node; // Present on optional property

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

_propertyAssignmentBrand: any;

name: DeclarationName;

questionToken?: Node;

initializer: Expression;

propertyName?: Identifier;

dotDotDotToken?: Node;

name: DeclarationName;

questionToken?: Node;

type?: TypeNode;

initializer?: Expression;

_functionLikeDeclarationBrand: any;

asteriskToken?: Node;

questionToken?: Node;

body?: Block | Expression;

left: Expression;

operatorToken: Node;

right: Expression;

condition: Expression;

questionToken: Node;

whenTrue: Expression;

colonToken: Node;

whenFalse: Expression;

text: string;

isUnterminated?: boolean;

hasExtendedUnicodeEscape?: boolean;

expression: LeftHandSideExpression;

dotToken: Node;

name: Identifier;

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

openingElement: JsxOpeningElement;

children: NodeArray<JsxChild>;

closingElement: JsxClosingElement;

_openingElementBrand?: any;

tagName: EntityName;

attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;

name: Identifier;

/// JSX attribute initializers are optional; <X y /> is sugar for <X y={true} />

initializer?: Expression;

expression: Expression;

thenStatement: Statement;

elseStatement?: Statement;

initializer?: VariableDeclarationList | Expression;

condition?: Expression;

incrementor?: Expression;