/*! *****************************************************************************

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 namespace ts {

const versionMajorMinor = "4.4";

/** The version of the TypeScript compiler release */

const version: string;

/**

* Type of objects whose values are all of the same type.

* The `in` and `for-in` operators can *not* be safely used,

* since `Object.prototype` may be modified by outside code.

*/

interface MapLike<T> {

[index: string]: T;

}

interface SortedReadonlyArray<T> extends ReadonlyArray<T> {

" __sortedArrayBrand": any;

}

interface SortedArray<T> extends Array<T> {

" __sortedArrayBrand": any;

}

/** Common read methods for ES6 Map/Set. */

interface ReadonlyCollection<K> {

readonly size: number;

has(key: K): boolean;

keys(): Iterator<K>;

}

/** Common write methods for ES6 Map/Set. */

interface Collection<K> extends ReadonlyCollection<K> {

delete(key: K): boolean;

clear(): void;

}

/** ES6 Map interface, only read methods included. */

interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {

get(key: K): V | undefined;

values(): Iterator<V>;

entries(): Iterator<[K, V]>;

forEach(action: (value: V, key: K) => void): void;

}

/**

* ES6 Map interface, only read methods included.

*/

interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {

}

/** ES6 Map interface. */

interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {

set(key: K, value: V): this;

}

/**

* ES6 Map interface.

*/

interface Map<T> extends ESMap<string, T> {

}

/** ES6 Set interface, only read methods included. */

interface ReadonlySet<T> extends ReadonlyCollection<T> {

has(value: T): boolean;

values(): Iterator<T>;

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

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

}

/** ES6 Set interface. */

interface Set<T> extends ReadonlySet<T>, Collection<T> {

add(value: T): this;

delete(value: T): boolean;

}

/** ES6 Iterator type. */

interface Iterator<T> {

next(): {

value: T;

done?: false;

} | {

value: void;

done: true;

};

}

/** Array that is only intended to be pushed to, never read. */

interface Push<T> {

push(...values: T[]): void;

}

}

declare namespace ts {

export type Path = string & {

__pathBrand: any;

};

export interface TextRange {

pos: number;

end: number;

}

export interface ReadonlyTextRange {

readonly pos: number;

readonly end: number;

}

export enum SyntaxKind {

Unknown = 0,

EndOfFileToken = 1,

SingleLineCommentTrivia = 2,

MultiLineCommentTrivia = 3,

NewLineTrivia = 4,

WhitespaceTrivia = 5,

ShebangTrivia = 6,

ConflictMarkerTrivia = 7,

NumericLiteral = 8,

BigIntLiteral = 9,

StringLiteral = 10,

JsxText = 11,

JsxTextAllWhiteSpaces = 12,

RegularExpressionLiteral = 13,

NoSubstitutionTemplateLiteral = 14,

TemplateHead = 15,

TemplateMiddle = 16,

TemplateTail = 17,

OpenBraceToken = 18,

CloseBraceToken = 19,

OpenParenToken = 20,

CloseParenToken = 21,

OpenBracketToken = 22,

CloseBracketToken = 23,

DotToken = 24,

DotDotDotToken = 25,

SemicolonToken = 26,

CommaToken = 27,

QuestionDotToken = 28,

LessThanToken = 29,

LessThanSlashToken = 30,

GreaterThanToken = 31,

LessThanEqualsToken = 32,

GreaterThanEqualsToken = 33,

EqualsEqualsToken = 34,

ExclamationEqualsToken = 35,

EqualsEqualsEqualsToken = 36,

ExclamationEqualsEqualsToken = 37,

EqualsGreaterThanToken = 38,

PlusToken = 39,

MinusToken = 40,

AsteriskToken = 41,

AsteriskAsteriskToken = 42,

SlashToken = 43,

PercentToken = 44,

PlusPlusToken = 45,

MinusMinusToken = 46,

LessThanLessThanToken = 47,

GreaterThanGreaterThanToken = 48,

GreaterThanGreaterThanGreaterThanToken = 49,

AmpersandToken = 50,

BarToken = 51,

CaretToken = 52,

ExclamationToken = 53,

TildeToken = 54,

AmpersandAmpersandToken = 55,

BarBarToken = 56,

QuestionToken = 57,

ColonToken = 58,

AtToken = 59,

QuestionQuestionToken = 60,

/** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */

BacktickToken = 61,

/** Only the JSDoc scanner produces HashToken. The normal scanner produces PrivateIdentifier. */

HashToken = 62,

EqualsToken = 63,

PlusEqualsToken = 64,

MinusEqualsToken = 65,

AsteriskEqualsToken = 66,

AsteriskAsteriskEqualsToken = 67,

SlashEqualsToken = 68,

PercentEqualsToken = 69,

LessThanLessThanEqualsToken = 70,

GreaterThanGreaterThanEqualsToken = 71,

GreaterThanGreaterThanGreaterThanEqualsToken = 72,

AmpersandEqualsToken = 73,

BarEqualsToken = 74,

BarBarEqualsToken = 75,

AmpersandAmpersandEqualsToken = 76,

QuestionQuestionEqualsToken = 77,

CaretEqualsToken = 78,

Identifier = 79,

PrivateIdentifier = 80,

BreakKeyword = 81,

CaseKeyword = 82,

CatchKeyword = 83,

ClassKeyword = 84,

ConstKeyword = 85,

ContinueKeyword = 86,

DebuggerKeyword = 87,

DefaultKeyword = 88,

DeleteKeyword = 89,

DoKeyword = 90,

ElseKeyword = 91,

EnumKeyword = 92,

ExportKeyword = 93,

ExtendsKeyword = 94,

FalseKeyword = 95,

FinallyKeyword = 96,

ForKeyword = 97,

FunctionKeyword = 98,

IfKeyword = 99,

ImportKeyword = 100,

InKeyword = 101,

InstanceOfKeyword = 102,

NewKeyword = 103,

NullKeyword = 104,

ReturnKeyword = 105,

SuperKeyword = 106,

SwitchKeyword = 107,

ThisKeyword = 108,

ThrowKeyword = 109,

TrueKeyword = 110,

TryKeyword = 111,

TypeOfKeyword = 112,

VarKeyword = 113,

VoidKeyword = 114,

WhileKeyword = 115,

WithKeyword = 116,

ImplementsKeyword = 117,

InterfaceKeyword = 118,

LetKeyword = 119,

PackageKeyword = 120,

PrivateKeyword = 121,

ProtectedKeyword = 122,

PublicKeyword = 123,

StaticKeyword = 124,

YieldKeyword = 125,

AbstractKeyword = 126,

AsKeyword = 127,

AssertsKeyword = 128,

AnyKeyword = 129,

AsyncKeyword = 130,

AwaitKeyword = 131,

BooleanKeyword = 132,

ConstructorKeyword = 133,

DeclareKeyword = 134,

GetKeyword = 135,

InferKeyword = 136,

IntrinsicKeyword = 137,

IsKeyword = 138,

KeyOfKeyword = 139,

ModuleKeyword = 140,

NamespaceKeyword = 141,

NeverKeyword = 142,

ReadonlyKeyword = 143,

RequireKeyword = 144,

NumberKeyword = 145,

ObjectKeyword = 146,

SetKeyword = 147,

StringKeyword = 148,

SymbolKeyword = 149,

TypeKeyword = 150,

UndefinedKeyword = 151,

UniqueKeyword = 152,

UnknownKeyword = 153,

FromKeyword = 154,

GlobalKeyword = 155,

BigIntKeyword = 156,

OverrideKeyword = 157,

OfKeyword = 158,

QualifiedName = 159,

ComputedPropertyName = 160,

TypeParameter = 161,

Parameter = 162,

Decorator = 163,

PropertySignature = 164,

PropertyDeclaration = 165,

MethodSignature = 166,

MethodDeclaration = 167,

ClassStaticBlockDeclaration = 168,

Constructor = 169,

GetAccessor = 170,

SetAccessor = 171,

CallSignature = 172,

ConstructSignature = 173,

IndexSignature = 174,

TypePredicate = 175,

TypeReference = 176,

FunctionType = 177,

ConstructorType = 178,

TypeQuery = 179,

TypeLiteral = 180,

ArrayType = 181,

TupleType = 182,

OptionalType = 183,

RestType = 184,

UnionType = 185,

IntersectionType = 186,

ConditionalType = 187,

InferType = 188,

ParenthesizedType = 189,

ThisType = 190,

TypeOperator = 191,

IndexedAccessType = 192,

MappedType = 193,

LiteralType = 194,

NamedTupleMember = 195,

TemplateLiteralType = 196,

TemplateLiteralTypeSpan = 197,

ImportType = 198,

ObjectBindingPattern = 199,

ArrayBindingPattern = 200,

BindingElement = 201,

ArrayLiteralExpression = 202,

ObjectLiteralExpression = 203,

PropertyAccessExpression = 204,

ElementAccessExpression = 205,

CallExpression = 206,

NewExpression = 207,

TaggedTemplateExpression = 208,

TypeAssertionExpression = 209,

ParenthesizedExpression = 210,

FunctionExpression = 211,

ArrowFunction = 212,

DeleteExpression = 213,

TypeOfExpression = 214,

VoidExpression = 215,

AwaitExpression = 216,

PrefixUnaryExpression = 217,

PostfixUnaryExpression = 218,

BinaryExpression = 219,

ConditionalExpression = 220,

TemplateExpression = 221,

YieldExpression = 222,

SpreadElement = 223,

ClassExpression = 224,

OmittedExpression = 225,

ExpressionWithTypeArguments = 226,

AsExpression = 227,

NonNullExpression = 228,

MetaProperty = 229,

SyntheticExpression = 230,

TemplateSpan = 231,

SemicolonClassElement = 232,

Block = 233,

EmptyStatement = 234,

VariableStatement = 235,

ExpressionStatement = 236,

IfStatement = 237,

DoStatement = 238,

WhileStatement = 239,

ForStatement = 240,

ForInStatement = 241,

ForOfStatement = 242,

ContinueStatement = 243,

BreakStatement = 244,

ReturnStatement = 245,

WithStatement = 246,

SwitchStatement = 247,

LabeledStatement = 248,

ThrowStatement = 249,

TryStatement = 250,

DebuggerStatement = 251,

VariableDeclaration = 252,

VariableDeclarationList = 253,

FunctionDeclaration = 254,

ClassDeclaration = 255,

InterfaceDeclaration = 256,

TypeAliasDeclaration = 257,

EnumDeclaration = 258,

ModuleDeclaration = 259,

ModuleBlock = 260,

CaseBlock = 261,

NamespaceExportDeclaration = 262,

ImportEqualsDeclaration = 263,

ImportDeclaration = 264,

ImportClause = 265,

NamespaceImport = 266,

NamedImports = 267,

ImportSpecifier = 268,

ExportAssignment = 269,

ExportDeclaration = 270,

NamedExports = 271,

NamespaceExport = 272,

ExportSpecifier = 273,

MissingDeclaration = 274,

ExternalModuleReference = 275,

JsxElement = 276,

JsxSelfClosingElement = 277,

JsxOpeningElement = 278,

JsxClosingElement = 279,

JsxFragment = 280,

JsxOpeningFragment = 281,

JsxClosingFragment = 282,

JsxAttribute = 283,

JsxAttributes = 284,

JsxSpreadAttribute = 285,

JsxExpression = 286,

CaseClause = 287,

DefaultClause = 288,

HeritageClause = 289,

CatchClause = 290,

PropertyAssignment = 291,

ShorthandPropertyAssignment = 292,

SpreadAssignment = 293,

EnumMember = 294,

UnparsedPrologue = 295,

UnparsedPrepend = 296,

UnparsedText = 297,

UnparsedInternalText = 298,

UnparsedSyntheticReference = 299,

SourceFile = 300,

Bundle = 301,

UnparsedSource = 302,

InputFiles = 303,

JSDocTypeExpression = 304,

JSDocNameReference = 305,

JSDocMemberName = 306,

JSDocAllType = 307,

JSDocUnknownType = 308,

JSDocNullableType = 309,

JSDocNonNullableType = 310,

JSDocOptionalType = 311,

JSDocFunctionType = 312,

JSDocVariadicType = 313,

JSDocNamepathType = 314,

JSDocComment = 315,

JSDocText = 316,

JSDocTypeLiteral = 317,

JSDocSignature = 318,

JSDocLink = 319,

JSDocLinkCode = 320,

JSDocLinkPlain = 321,

JSDocTag = 322,

JSDocAugmentsTag = 323,

JSDocImplementsTag = 324,

JSDocAuthorTag = 325,

JSDocDeprecatedTag = 326,

JSDocClassTag = 327,

JSDocPublicTag = 328,

JSDocPrivateTag = 329,

JSDocProtectedTag = 330,

JSDocReadonlyTag = 331,

JSDocOverrideTag = 332,

JSDocCallbackTag = 333,

JSDocEnumTag = 334,

JSDocParameterTag = 335,

JSDocReturnTag = 336,

JSDocThisTag = 337,

JSDocTypeTag = 338,

JSDocTemplateTag = 339,

JSDocTypedefTag = 340,

JSDocSeeTag = 341,

JSDocPropertyTag = 342,

SyntaxList = 343,

NotEmittedStatement = 344,

PartiallyEmittedExpression = 345,

CommaListExpression = 346,

MergeDeclarationMarker = 347,

EndOfDeclarationMarker = 348,

SyntheticReferenceExpression = 349,

Count = 350,

FirstAssignment = 63,

LastAssignment = 78,

FirstCompoundAssignment = 64,

LastCompoundAssignment = 78,

FirstReservedWord = 81,

LastReservedWord = 116,

FirstKeyword = 81,

LastKeyword = 158,

FirstFutureReservedWord = 117,

LastFutureReservedWord = 125,

FirstTypeNode = 175,

LastTypeNode = 198,

FirstPunctuation = 18,

LastPunctuation = 78,

FirstToken = 0,

LastToken = 158,

FirstTriviaToken = 2,

LastTriviaToken = 7,

FirstLiteralToken = 8,

LastLiteralToken = 14,

FirstTemplateToken = 14,

LastTemplateToken = 17,

FirstBinaryOperator = 29,

LastBinaryOperator = 78,

FirstStatement = 235,

LastStatement = 251,

FirstNode = 159,

FirstJSDocNode = 304,

LastJSDocNode = 342,

FirstJSDocTagNode = 322,

LastJSDocTagNode = 342,

}

export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;

export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral;

export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail;

export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken;

export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword;

export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword;

export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword;

export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind;

export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;

export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.Unknown | KeywordSyntaxKind;

export enum NodeFlags {

None = 0,

Let = 1,

Const = 2,

NestedNamespace = 4,

Synthesized = 8,

Namespace = 16,

OptionalChain = 32,

ExportContext = 64,

ContainsThis = 128,

HasImplicitReturn = 256,

HasExplicitReturn = 512,

GlobalAugmentation = 1024,

HasAsyncFunctions = 2048,

DisallowInContext = 4096,

YieldContext = 8192,

DecoratorContext = 16384,

AwaitContext = 32768,

ThisNodeHasError = 65536,

JavaScriptFile = 131072,

ThisNodeOrAnySubNodesHasError = 262144,

HasAggregatedChildData = 524288,

JSDoc = 4194304,

JsonFile = 33554432,

BlockScoped = 3,

ReachabilityCheckFlags = 768,

ReachabilityAndEmitFlags = 2816,

ContextFlags = 25358336,

TypeExcludesFlags = 40960,

}

export enum ModifierFlags {

None = 0,

Export = 1,

Ambient = 2,

Public = 4,

Private = 8,

Protected = 16,

Static = 32,

Readonly = 64,

Abstract = 128,

Async = 256,

Default = 512,

Const = 2048,

HasComputedJSDocModifiers = 4096,

Deprecated = 8192,

Override = 16384,

HasComputedFlags = 536870912,

AccessibilityModifier = 28,

ParameterPropertyModifier = 16476,

NonPublicAccessibilityModifier = 24,

TypeScriptModifier = 18654,

ExportDefault = 513,

All = 27647

}

export enum JsxFlags {

None = 0,

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

IntrinsicNamedElement = 1,

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

IntrinsicIndexedElement = 2,

IntrinsicElement = 3

}

export interface Node extends ReadonlyTextRange {

readonly kind: SyntaxKind;

readonly flags: NodeFlags;

readonly decorators?: NodeArray<Decorator>;

readonly modifiers?: ModifiersArray;

readonly parent: Node;

}

export interface JSDocContainer {

}

export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ClassStaticBlockDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | EmptyStatement | DebuggerStatement | Block | VariableStatement | ExpressionStatement | IfStatement | DoStatement | WhileStatement | ForStatement | ForInStatement | ForOfStatement | BreakStatement | ContinueStatement | ReturnStatement | WithStatement | SwitchStatement | LabeledStatement | ThrowStatement | TryStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | VariableDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | NamespaceExportDeclaration | ExportAssignment | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | NamedTupleMember | EndOfFileToken;

export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;

export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;

export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;

export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertySignature | PropertyDeclaration | PropertyAssignment | EnumMember;

export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {

readonly hasTrailingComma: boolean;

}

export interface Token<TKind extends SyntaxKind> extends Node {

readonly kind: TKind;

}

export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer;

export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {

}

export type DotToken = PunctuationToken<SyntaxKind.DotToken>;

export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;

export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;

export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;

export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>;

export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>;

export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>;

export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>;

export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>;

export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>;

export type QuestionDotToken = PunctuationToken<SyntaxKind.QuestionDotToken>;

export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKind> {

}

export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>;

export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>;

/** @deprecated Use `AwaitKeyword` instead. */

export type AwaitKeywordToken = AwaitKeyword;

/** @deprecated Use `AssertsKeyword` instead. */

export type AssertsToken = AssertsKeyword;

export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> {

}

export type AbstractKeyword = ModifierToken<SyntaxKind.AbstractKeyword>;

export type AsyncKeyword = ModifierToken<SyntaxKind.AsyncKeyword>;

export type ConstKeyword = ModifierToken<SyntaxKind.ConstKeyword>;

export type DeclareKeyword = ModifierToken<SyntaxKind.DeclareKeyword>;

export type DefaultKeyword = ModifierToken<SyntaxKind.DefaultKeyword>;

export type ExportKeyword = ModifierToken<SyntaxKind.ExportKeyword>;

export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>;

export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>;

export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>;

export type ReadonlyKeyword = ModifierToken<SyntaxKind.ReadonlyKeyword>;

export type OverrideKeyword = ModifierToken<SyntaxKind.OverrideKeyword>;

export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;

/** @deprecated Use `ReadonlyKeyword` instead. */

export type ReadonlyToken = ReadonlyKeyword;

export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword;

export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword;

export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword;

export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword;

export type ModifiersArray = NodeArray<Modifier>;

export enum GeneratedIdentifierFlags {

None = 0,

ReservedInNestedScopes = 8,

Optimistic = 16,

FileLevel = 32,

AllowNameSubstitution = 64

}

export interface Identifier extends PrimaryExpression, Declaration {

readonly kind: SyntaxKind.Identifier;

/**

* Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.)

* Text of identifier, but if the identifier begins with two underscores, this will begin with three.

*/

readonly escapedText: __String;

readonly originalKeywordKind?: SyntaxKind;

isInJSDocNamespace?: boolean;

}

export interface TransientIdentifier extends Identifier {

resolvedSymbol: Symbol;

}

export interface QualifiedName extends Node {

readonly kind: SyntaxKind.QualifiedName;

readonly left: EntityName;

readonly right: Identifier;

}

export type EntityName = Identifier | QualifiedName;

export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier;

export type MemberName = Identifier | PrivateIdentifier;

export type DeclarationName = Identifier | PrivateIdentifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression;

export interface Declaration extends Node {

_declarationBrand: any;

}

export interface NamedDeclaration extends Declaration {

readonly name?: DeclarationName;

}

export interface DeclarationStatement extends NamedDeclaration, Statement {

readonly name?: Identifier | StringLiteral | NumericLiteral;

}

export interface ComputedPropertyName extends Node {

readonly kind: SyntaxKind.ComputedPropertyName;

readonly parent: Declaration;

readonly expression: Expression;

}

export interface PrivateIdentifier extends Node {

readonly kind: SyntaxKind.PrivateIdentifier;

readonly escapedText: __String;

}

export interface Decorator extends Node {

readonly kind: SyntaxKind.Decorator;

readonly parent: NamedDeclaration;

readonly expression: LeftHandSideExpression;

}

export interface TypeParameterDeclaration extends NamedDeclaration {

readonly kind: SyntaxKind.TypeParameter;

readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode;

readonly name: Identifier;

/** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */

readonly constraint?: TypeNode;

readonly default?: TypeNode;

expression?: Expression;

}

export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {

readonly kind: SignatureDeclaration["kind"];

readonly name?: PropertyName;

readonly typeParameters?: NodeArray<TypeParameterDeclaration>;

readonly parameters: NodeArray<ParameterDeclaration>;

readonly type?: TypeNode;

}

export type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction;

export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {

readonly kind: SyntaxKind.CallSignature;

}

export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement {

readonly kind: SyntaxKind.ConstructSignature;

}

export type BindingName = Identifier | BindingPattern;

export interface VariableDeclaration extends NamedDeclaration, JSDocContainer {

readonly kind: SyntaxKind.VariableDeclaration;

readonly parent: VariableDeclarationList | CatchClause;

readonly name: BindingName;

readonly exclamationToken?: ExclamationToken;

readonly type?: TypeNode;

readonly initializer?: Expression;

}

export interface VariableDeclarationList extends Node {

readonly kind: SyntaxKind.VariableDeclarationList;

readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;

readonly declarations: NodeArray<VariableDeclaration>;

}

export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {

readonly kind: SyntaxKind.Parameter;

readonly parent: SignatureDeclaration;

readonly dotDotDotToken?: DotDotDotToken;

readonly name: BindingName;

readonly questionToken?: QuestionToken;

readonly type?: TypeNode;

readonly initializer?: Expression;

}

export interface BindingElement extends NamedDeclaration {

readonly kind: SyntaxKind.BindingElement;

readonly parent: BindingPattern;

readonly propertyName?: PropertyName;

readonly dotDotDotToken?: DotDotDotToken;

readonly name: BindingName;

readonly initializer?: Expression;

}

export interface PropertySignature extends TypeElement, JSDocContainer {

readonly kind: SyntaxKind.PropertySignature;

readonly name: PropertyName;

readonly questionToken?: QuestionToken;

readonly type?: TypeNode;

initializer?: Expression;

}

export interface PropertyDeclaration extends ClassElement, JSDocContainer {

readonly kind: SyntaxKind.PropertyDeclaration;

readonly parent: ClassLikeDeclaration;

readonly name: PropertyName;

readonly questionToken?: QuestionToken;

readonly exclamationToken?: ExclamationToken;

readonly type?: TypeNode;

readonly initializer?: Expression;

}

export interface ObjectLiteralElement extends NamedDeclaration {

_objectLiteralBrand: any;

readonly name?: PropertyName;

}

/** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */

export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;

export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.PropertyAssignment;

readonly parent: ObjectLiteralExpression;

readonly name: PropertyName;

readonly questionToken?: QuestionToken;

readonly exclamationToken?: ExclamationToken;

readonly initializer: Expression;

}

export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.ShorthandPropertyAssignment;

readonly parent: ObjectLiteralExpression;

readonly name: Identifier;

readonly questionToken?: QuestionToken;

readonly exclamationToken?: ExclamationToken;

readonly equalsToken?: EqualsToken;

readonly objectAssignmentInitializer?: Expression;

}

export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.SpreadAssignment;

readonly parent: ObjectLiteralExpression;

readonly expression: Expression;

}

export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;

export interface PropertyLikeDeclaration extends NamedDeclaration {

readonly name: PropertyName;

}

export interface ObjectBindingPattern extends Node {

readonly kind: SyntaxKind.ObjectBindingPattern;

readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;

readonly elements: NodeArray<BindingElement>;

}

export interface ArrayBindingPattern extends Node {

readonly kind: SyntaxKind.ArrayBindingPattern;

readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;

readonly elements: NodeArray<ArrayBindingElement>;

}

export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;

export type ArrayBindingElement = BindingElement | OmittedExpression;

/**

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

* a name, and a body. These nodes should extend FunctionLikeDeclarationBase.

* Examples:

* - FunctionDeclaration

* - MethodDeclaration

* - AccessorDeclaration

*/

export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {

_functionLikeDeclarationBrand: any;

readonly asteriskToken?: AsteriskToken;

readonly questionToken?: QuestionToken;

readonly exclamationToken?: ExclamationToken;

readonly body?: Block | Expression;

}

export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;

/** @deprecated Use SignatureDeclaration */

export type FunctionLike = SignatureDeclaration;

export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement {

readonly kind: SyntaxKind.FunctionDeclaration;

readonly name?: Identifier;

readonly body?: FunctionBody;

}

export interface MethodSignature extends SignatureDeclarationBase, TypeElement {

readonly kind: SyntaxKind.MethodSignature;

readonly parent: ObjectTypeDeclaration;

readonly name: PropertyName;

}

export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.MethodDeclaration;

readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;

readonly name: PropertyName;

readonly body?: FunctionBody;

}

export interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer {

readonly kind: SyntaxKind.Constructor;

readonly parent: ClassLikeDeclaration;

readonly body?: FunctionBody;

}

/** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */

export interface SemicolonClassElement extends ClassElement {

readonly kind: SyntaxKind.SemicolonClassElement;

readonly parent: ClassLikeDeclaration;

}

export interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.GetAccessor;

readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;

readonly name: PropertyName;

readonly body?: FunctionBody;

}

export interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.SetAccessor;

readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;

readonly name: PropertyName;

readonly body?: FunctionBody;

}

export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;

export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement {

readonly kind: SyntaxKind.IndexSignature;

readonly parent: ObjectTypeDeclaration;

readonly type: TypeNode;

}

export interface ClassStaticBlockDeclaration extends ClassElement, JSDocContainer {

readonly kind: SyntaxKind.ClassStaticBlockDeclaration;

readonly parent: ClassDeclaration | ClassExpression;

readonly body: Block;

}

export interface TypeNode extends Node {

_typeNodeBrand: any;

}

export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode {

readonly kind: TKind;

}

export interface ImportTypeNode extends NodeWithTypeArguments {

readonly kind: SyntaxKind.ImportType;

readonly isTypeOf: boolean;

readonly argument: TypeNode;

readonly qualifier?: EntityName;

}

export interface ThisTypeNode extends TypeNode {

readonly kind: SyntaxKind.ThisType;

}

export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;

export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {

readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;

readonly type: TypeNode;

}

export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase {

readonly kind: SyntaxKind.FunctionType;

}

export interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase {

readonly kind: SyntaxKind.ConstructorType;

}

export interface NodeWithTypeArguments extends TypeNode {

readonly typeArguments?: NodeArray<TypeNode>;

}

export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;

export interface TypeReferenceNode extends NodeWithTypeArguments {

readonly kind: SyntaxKind.TypeReference;

readonly typeName: EntityName;

}

export interface TypePredicateNode extends TypeNode {

readonly kind: SyntaxKind.TypePredicate;

readonly parent: SignatureDeclaration | JSDocTypeExpression;

readonly assertsModifier?: AssertsToken;

readonly parameterName: Identifier | ThisTypeNode;

readonly type?: TypeNode;

}

export interface TypeQueryNode extends TypeNode {

readonly kind: SyntaxKind.TypeQuery;

readonly exprName: EntityName;

}

export interface TypeLiteralNode extends TypeNode, Declaration {

readonly kind: SyntaxKind.TypeLiteral;

readonly members: NodeArray<TypeElement>;

}

export interface ArrayTypeNode extends TypeNode {

readonly kind: SyntaxKind.ArrayType;

readonly elementType: TypeNode;

}

export interface TupleTypeNode extends TypeNode {

readonly kind: SyntaxKind.TupleType;

readonly elements: NodeArray<TypeNode | NamedTupleMember>;

}

export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {

readonly kind: SyntaxKind.NamedTupleMember;

readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;

readonly name: Identifier;

readonly questionToken?: Token<SyntaxKind.QuestionToken>;

readonly type: TypeNode;

}

export interface OptionalTypeNode extends TypeNode {

readonly kind: SyntaxKind.OptionalType;

readonly type: TypeNode;

}

export interface RestTypeNode extends TypeNode {

readonly kind: SyntaxKind.RestType;

readonly type: TypeNode;

}

export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;

export interface UnionTypeNode extends TypeNode {

readonly kind: SyntaxKind.UnionType;

readonly types: NodeArray<TypeNode>;

}

export interface IntersectionTypeNode extends TypeNode {

readonly kind: SyntaxKind.IntersectionType;

readonly types: NodeArray<TypeNode>;

}

export interface ConditionalTypeNode extends TypeNode {

readonly kind: SyntaxKind.ConditionalType;

readonly checkType: TypeNode;

readonly extendsType: TypeNode;

readonly trueType: TypeNode;

readonly falseType: TypeNode;

}

export interface InferTypeNode extends TypeNode {

readonly kind: SyntaxKind.InferType;

readonly typeParameter: TypeParameterDeclaration;

}

export interface ParenthesizedTypeNode extends TypeNode {

readonly kind: SyntaxKind.ParenthesizedType;

readonly type: TypeNode;

}

export interface TypeOperatorNode extends TypeNode {

readonly kind: SyntaxKind.TypeOperator;

readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;

readonly type: TypeNode;

}

export interface IndexedAccessTypeNode extends TypeNode {

readonly kind: SyntaxKind.IndexedAccessType;

readonly objectType: TypeNode;

readonly indexType: TypeNode;

}

export interface MappedTypeNode extends TypeNode, Declaration {

readonly kind: SyntaxKind.MappedType;

readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;

readonly typeParameter: TypeParameterDeclaration;

readonly nameType?: TypeNode;

readonly questionToken?: QuestionToken | PlusToken | MinusToken;

readonly type?: TypeNode;

}

export interface LiteralTypeNode extends TypeNode {

readonly kind: SyntaxKind.LiteralType;

readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression;

}

export interface StringLiteral extends LiteralExpression, Declaration {

readonly kind: SyntaxKind.StringLiteral;

}

export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;

export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;

export interface TemplateLiteralTypeNode extends TypeNode {

kind: SyntaxKind.TemplateLiteralType;

readonly head: TemplateHead;

readonly templateSpans: NodeArray<TemplateLiteralTypeSpan>;

}

export interface TemplateLiteralTypeSpan extends TypeNode {

readonly kind: SyntaxKind.TemplateLiteralTypeSpan;

readonly parent: TemplateLiteralTypeNode;

readonly type: TypeNode;

readonly literal: TemplateMiddle | TemplateTail;

}

export interface Expression extends Node {

_expressionBrand: any;

}

export interface OmittedExpression extends Expression {

readonly kind: SyntaxKind.OmittedExpression;

}

export interface PartiallyEmittedExpression extends LeftHandSideExpression {

readonly kind: SyntaxKind.PartiallyEmittedExpression;