get(key: string): T;

has(key: string): boolean;

set(key: string, value: T): this;

delete(key: string): boolean;

clear(): void;

forEach(action: (value: T, key: string) => void): void;

readonly size: number;

keys(): Iterator<string>;

values(): Iterator<T>;

entries(): Iterator<[string, T]>;

get(fileName: Path): T;

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

contains(fileName: Path): boolean;

remove(fileName: Path): void;

forEachValue(f: (key: Path, v: T) => void): void;

getKeys(): Path[];

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,

JsxText,

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,

AsteriskAsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

AsteriskAsteriskEqualsToken,

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,

KeyOfKeyword,

ModuleKeyword,

NamespaceKeyword,

NeverKeyword,

ReadonlyKeyword,

RequireKeyword,

NumberKeyword,

ObjectKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

UndefinedKeyword,

FromKeyword,

GlobalKeyword,

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,

ThisType,

TypeOperator,

IndexedAccessType,

MappedType,

LiteralType,

// 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,

SpreadElement,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

AsExpression,

NonNullExpression,

MetaProperty,

// 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,

NamespaceExportDeclaration,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// JSX

JsxElement,

JsxSelfClosingElement,

JsxOpeningElement,

JsxClosingElement,

JsxAttribute,

JsxAttributes,

JsxSpreadAttribute,

JsxExpression,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

SpreadAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

Bundle,

// JSDoc nodes

JSDocTypeExpression,

// The * type

JSDocAllType,

// The ? type

JSDocUnknownType,

JSDocArrayType,

JSDocUnionType,

JSDocTupleType,

JSDocNullableType,

JSDocNonNullableType,

JSDocRecordType,

JSDocRecordMember,

JSDocTypeReference,

JSDocOptionalType,

JSDocFunctionType,

JSDocVariadicType,

JSDocConstructorType,

JSDocThisType,

JSDocComment,

JSDocTag,

JSDocAugmentsTag,

JSDocParameterTag,

JSDocReturnTag,

JSDocTypeTag,

JSDocTemplateTag,

JSDocTypedefTag,

JSDocPropertyTag,

JSDocTypeLiteral,

JSDocLiteralType,

// Synthesized list

SyntaxList,

// Transformation nodes

NotEmittedStatement,

PartiallyEmittedExpression,

MergeDeclarationMarker,

EndOfDeclarationMarker,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstCompoundAssignment = PlusEqualsToken,

LastCompoundAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypePredicate,

LastTypeNode = LiteralType,

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,

FirstJSDocNode = JSDocTypeExpression,

LastJSDocNode = JSDocLiteralType,

FirstJSDocTagNode = JSDocComment,

LastJSDocTagNode = JSDocLiteralType

None = 0,

Let = 1 << 0, // Variable declaration

Const = 1 << 1, // Variable declaration

NestedNamespace = 1 << 2, // Namespace declaration

Synthesized = 1 << 3, // Node was synthesized during transformation

Namespace = 1 << 4, // Namespace declaration

ExportContext = 1 << 5, // Export context (initialized by binding)

ContainsThis = 1 << 6, // Interface contains references to "this"

HasImplicitReturn = 1 << 7, // If function implicitly returns on one of codepaths (initialized by binding)

HasExplicitReturn = 1 << 8, // If function has explicit reachable return on one of codepaths (initialized by binding)

GlobalAugmentation = 1 << 9, // Set if module declaration is an augmentation for the global scope

HasAsyncFunctions = 1 << 10, // If the file has async functions (initialized by binding)

DisallowInContext = 1 << 11, // If node was parsed in a context where 'in-expressions' are not allowed

YieldContext = 1 << 12, // If node was parsed in the 'yield' context created when parsing a generator

DecoratorContext = 1 << 13, // If node was parsed as part of a decorator

AwaitContext = 1 << 14, // If node was parsed in the 'await' context created when parsing an async function

ThisNodeHasError = 1 << 15, // If the parser encountered an error when parsing the code that created this node

JavaScriptFile = 1 << 16, // If node was parsed in a JavaScript

ThisNodeOrAnySubNodesHasError = 1 << 17, // If this node or any of its children had an error

HasAggregatedChildData = 1 << 18, // If we've computed data from children and cached it in this node

BlockScoped = Let | Const,

ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,

ReachabilityAndEmitFlags = ReachabilityCheckFlags | HasAsyncFunctions,

// Parsing context flags

ContextFlags = DisallowInContext | YieldContext | DecoratorContext | AwaitContext | JavaScriptFile,

// Exclude these flags when parsing a Type

TypeExcludesFlags = YieldContext | AwaitContext,

None = 0,

Export = 1 << 0, // Declarations

Ambient = 1 << 1, // Declarations

Public = 1 << 2, // Property/Method

Private = 1 << 3, // Property/Method

Protected = 1 << 4, // Property/Method

Static = 1 << 5, // Property/Method

Readonly = 1 << 6, // Property/Method

Abstract = 1 << 7, // Class/Method/ConstructSignature

Async = 1 << 8, // Property/Method/Function

Default = 1 << 9, // Function/Class (export default declaration)

Const = 1 << 11, // Variable declaration

HasComputedFlags = 1 << 29, // Modifier flags have been computed

AccessibilityModifier = Public | Private | Protected,

// Accessibility modifiers and 'readonly' can be attached to a parameter in a constructor to make it a property.

ParameterPropertyModifier = AccessibilityModifier | Readonly,

NonPublicAccessibilityModifier = Private | Protected,

TypeScriptModifier = Ambient | Public | Private | Protected | Readonly | Abstract | Const,

ExportDefault = Export | Default,

None = 0,

/** An element from a named property of the JSX.IntrinsicElements interface */

IntrinsicNamedElement = 1 << 0,

/** An element inferred from the string index signature of the JSX.IntrinsicElements interface */

IntrinsicIndexedElement = 1 << 1,

IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement,

Succeeded = 1, // Should be truthy

Failed = 2,

FailedAndReported = 3

kind: SyntaxKind;

flags: NodeFlags;

/* @internal */ modifierFlagsCache?: ModifierFlags;

/* @internal */ transformFlags?: TransformFlags;

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 */ original?: Node; // The original node if this is an updated node.

/* @internal */ startsOnNewLine?: boolean; // Whether a synthesized node should start on a new line (used by transforms).

/* @internal */ jsDoc?: JSDoc[]; // JSDoc that directly precedes this node

/* @internal */ jsDocCache?: (JSDoc | JSDocTag)[]; // All JSDoc that applies to the node, including parent docs and @param tags

/* @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)

/* @internal */ flowNode?: FlowNode; // Associated FlowNode (initialized by binding)

/* @internal */ emitNode?: EmitNode; // Associated EmitNode (initialized by transforms)

= Token<SyntaxKind.AbstractKeyword>

| Token<SyntaxKind.AsyncKeyword>

| Token<SyntaxKind.ConstKeyword>

| Token<SyntaxKind.DeclareKeyword>

| Token<SyntaxKind.DefaultKeyword>

| Token<SyntaxKind.ExportKeyword>

| Token<SyntaxKind.PublicKeyword>

| Token<SyntaxKind.PrivateKeyword>

| Token<SyntaxKind.ProtectedKeyword>

| Token<SyntaxKind.ReadonlyKeyword>

| Token<SyntaxKind.StaticKeyword>

None, // Not automatically generated.

Auto, // Automatically generated identifier.

Loop, // Automatically generated identifier with a preference for '_i'.

Unique, // Unique name based on the 'text' property.

Node, // Unique name based on the node in the 'original' property.

kind: SyntaxKind.Identifier;

text: string; // Text of identifier (with escapes converted to characters)

originalKeywordKind?: SyntaxKind; // Original syntaxKind which get set so that we can report an error later

/*@internal*/ autoGenerateKind?: GeneratedIdentifierKind; // Specifies whether to auto-generate the text for an identifier.

/*@internal*/ autoGenerateId?: number; // Ensures unique generated identifiers get unique names, but clones get the same name.

isInJSDocNamespace?: boolean; // if the node is a member in a JSDoc namespace

autoGenerateKind: GeneratedIdentifierKind.Auto

| GeneratedIdentifierKind.Loop

| GeneratedIdentifierKind.Unique

| GeneratedIdentifierKind.Node;

kind: SyntaxKind.QualifiedName;

left: EntityName;

right: Identifier;

kind: SyntaxKind.TypeParameter;

parent?: DeclarationWithTypeParameters;

name: Identifier;

constraint?: TypeNode;

default?: TypeNode;

// For error recovery purposes.

expression?: Expression;

name?: PropertyName;

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

kind: SyntaxKind.VariableDeclaration;

parent?: VariableDeclarationList | CatchClause;

name: BindingName; // Declared variable name

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

kind: SyntaxKind.VariableDeclarationList;

parent?: VariableStatement | ForStatement | ForOfStatement | ForInStatement;

declarations: NodeArray<VariableDeclaration>;

kind: SyntaxKind.Parameter;

parent?: SignatureDeclaration;

dotDotDotToken?: DotDotDotToken; // Present on rest parameter

name: BindingName; // Declared parameter name

questionToken?: QuestionToken; // Present on optional parameter

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

kind: SyntaxKind.BindingElement;

parent?: BindingPattern;

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

dotDotDotToken?: DotDotDotToken; // Present on rest element (in object binding pattern)

name: BindingName; // Declared binding element name

initializer?: Expression; // Optional initializer

kind: SyntaxKind.PropertySignature | SyntaxKind.JSDocRecordMember;

name: PropertyName; // Declared property name

questionToken?: QuestionToken; // Present on optional property

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

kind: SyntaxKind.PropertyDeclaration;

questionToken?: QuestionToken; // Present for use with reporting a grammar error

name: PropertyName;

type?: TypeNode;

initializer?: Expression; // Optional initializer

= PropertyAssignment

| ShorthandPropertyAssignment

| SpreadAssignment

| MethodDeclaration

| AccessorDeclaration

kind: SyntaxKind.PropertyAssignment;

name: PropertyName;

questionToken?: QuestionToken;

initializer: Expression;

kind: SyntaxKind.ShorthandPropertyAssignment;

name: Identifier;

questionToken?: QuestionToken;

// used when ObjectLiteralExpression is used in ObjectAssignmentPattern

// it is grammar error to appear in actual object initializer

equalsToken?: Token<SyntaxKind.EqualsToken>;

objectAssignmentInitializer?: Expression;

propertyName?: PropertyName;

dotDotDotToken?: DotDotDotToken;

name: DeclarationName;

questionToken?: QuestionToken;

type?: TypeNode;

initializer?: Expression;

kind: SyntaxKind.ObjectBindingPattern;

parent?: VariableDeclaration | ParameterDeclaration | BindingElement;

elements: NodeArray<BindingElement>;

kind: SyntaxKind.ArrayBindingPattern;

parent?: VariableDeclaration | ParameterDeclaration | BindingElement;

elements: NodeArray<ArrayBindingElement>;

_functionLikeDeclarationBrand: any;

asteriskToken?: AsteriskToken;

questionToken?: QuestionToken;

body?: Block | Expression;

kind: SyntaxKind.FunctionDeclaration;

name?: Identifier;

body?: FunctionBody;

kind: SyntaxKind.MethodDeclaration;

name: PropertyName;

body?: FunctionBody;

kind: SyntaxKind.GetAccessor;

name: PropertyName;

body: FunctionBody;

kind: SyntaxKind.SetAccessor;

name: PropertyName;

body: FunctionBody;

kind: SyntaxKind.AnyKeyword

| SyntaxKind.NumberKeyword

| SyntaxKind.ObjectKeyword

| SyntaxKind.BooleanKeyword

| SyntaxKind.StringKeyword

| SyntaxKind.SymbolKeyword

| SyntaxKind.VoidKeyword;

kind: SyntaxKind.TypeReference;

typeName: EntityName;

typeArguments?: NodeArray<TypeNode>;

kind: SyntaxKind.TypePredicate;