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

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.0";

/** 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;

}

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

interface ReadonlyMap<T> {

get(key: string): T | undefined;

has(key: string): boolean;

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

readonly size: number;

keys(): Iterator<string>;

values(): Iterator<T>;

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

}

/** ES6 Map interface. */

interface Map<T> extends ReadonlyMap<T> {

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

delete(key: string): boolean;

clear(): void;

}

/** ES6 Iterator type. */

interface Iterator<T> {

next(): {

value: T;

done?: false;

} | {

value: never;

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,

EqualsToken = 62,

PlusEqualsToken = 63,

MinusEqualsToken = 64,

AsteriskEqualsToken = 65,

AsteriskAsteriskEqualsToken = 66,

SlashEqualsToken = 67,

PercentEqualsToken = 68,

LessThanLessThanEqualsToken = 69,

GreaterThanGreaterThanEqualsToken = 70,

GreaterThanGreaterThanGreaterThanEqualsToken = 71,

AmpersandEqualsToken = 72,

BarEqualsToken = 73,

BarBarEqualsToken = 74,

AmpersandAmpersandEqualsToken = 75,

QuestionQuestionEqualsToken = 76,

CaretEqualsToken = 77,

Identifier = 78,

PrivateIdentifier = 79,

BreakKeyword = 80,

CaseKeyword = 81,

CatchKeyword = 82,

ClassKeyword = 83,

ConstKeyword = 84,

ContinueKeyword = 85,

DebuggerKeyword = 86,

DefaultKeyword = 87,

DeleteKeyword = 88,

DoKeyword = 89,

ElseKeyword = 90,

EnumKeyword = 91,

ExportKeyword = 92,

ExtendsKeyword = 93,

FalseKeyword = 94,

FinallyKeyword = 95,

ForKeyword = 96,

FunctionKeyword = 97,

IfKeyword = 98,

ImportKeyword = 99,

InKeyword = 100,

InstanceOfKeyword = 101,

NewKeyword = 102,

NullKeyword = 103,

ReturnKeyword = 104,

SuperKeyword = 105,

SwitchKeyword = 106,

ThisKeyword = 107,

ThrowKeyword = 108,

TrueKeyword = 109,

TryKeyword = 110,

TypeOfKeyword = 111,

VarKeyword = 112,

VoidKeyword = 113,

WhileKeyword = 114,

WithKeyword = 115,

ImplementsKeyword = 116,

InterfaceKeyword = 117,

LetKeyword = 118,

PackageKeyword = 119,

PrivateKeyword = 120,

ProtectedKeyword = 121,

PublicKeyword = 122,

StaticKeyword = 123,

YieldKeyword = 124,

AbstractKeyword = 125,

AsKeyword = 126,

AssertsKeyword = 127,

AnyKeyword = 128,

AsyncKeyword = 129,

AwaitKeyword = 130,

BooleanKeyword = 131,

ConstructorKeyword = 132,

DeclareKeyword = 133,

GetKeyword = 134,

InferKeyword = 135,

IsKeyword = 136,

KeyOfKeyword = 137,

ModuleKeyword = 138,

NamespaceKeyword = 139,

NeverKeyword = 140,

ReadonlyKeyword = 141,

RequireKeyword = 142,

NumberKeyword = 143,

ObjectKeyword = 144,

SetKeyword = 145,

StringKeyword = 146,

SymbolKeyword = 147,

TypeKeyword = 148,

UndefinedKeyword = 149,

UniqueKeyword = 150,

UnknownKeyword = 151,

FromKeyword = 152,

GlobalKeyword = 153,

BigIntKeyword = 154,

OfKeyword = 155,

QualifiedName = 156,

ComputedPropertyName = 157,

TypeParameter = 158,

Parameter = 159,

Decorator = 160,

PropertySignature = 161,

PropertyDeclaration = 162,

MethodSignature = 163,

MethodDeclaration = 164,

Constructor = 165,

GetAccessor = 166,

SetAccessor = 167,

CallSignature = 168,

ConstructSignature = 169,

IndexSignature = 170,

TypePredicate = 171,

TypeReference = 172,

FunctionType = 173,

ConstructorType = 174,

TypeQuery = 175,

TypeLiteral = 176,

ArrayType = 177,

TupleType = 178,

OptionalType = 179,

RestType = 180,

UnionType = 181,

IntersectionType = 182,

ConditionalType = 183,

InferType = 184,

ParenthesizedType = 185,

ThisType = 186,

TypeOperator = 187,

IndexedAccessType = 188,

MappedType = 189,

LiteralType = 190,

NamedTupleMember = 191,

ImportType = 192,

ObjectBindingPattern = 193,

ArrayBindingPattern = 194,

BindingElement = 195,

ArrayLiteralExpression = 196,

ObjectLiteralExpression = 197,

PropertyAccessExpression = 198,

ElementAccessExpression = 199,

CallExpression = 200,

NewExpression = 201,

TaggedTemplateExpression = 202,

TypeAssertionExpression = 203,

ParenthesizedExpression = 204,

FunctionExpression = 205,

ArrowFunction = 206,

DeleteExpression = 207,

TypeOfExpression = 208,

VoidExpression = 209,

AwaitExpression = 210,

PrefixUnaryExpression = 211,

PostfixUnaryExpression = 212,

BinaryExpression = 213,

ConditionalExpression = 214,

TemplateExpression = 215,

YieldExpression = 216,

SpreadElement = 217,

ClassExpression = 218,

OmittedExpression = 219,

ExpressionWithTypeArguments = 220,

AsExpression = 221,

NonNullExpression = 222,

MetaProperty = 223,

SyntheticExpression = 224,

TemplateSpan = 225,

SemicolonClassElement = 226,

Block = 227,

EmptyStatement = 228,

VariableStatement = 229,

ExpressionStatement = 230,

IfStatement = 231,

DoStatement = 232,

WhileStatement = 233,

ForStatement = 234,

ForInStatement = 235,

ForOfStatement = 236,

ContinueStatement = 237,

BreakStatement = 238,

ReturnStatement = 239,

WithStatement = 240,

SwitchStatement = 241,

LabeledStatement = 242,

ThrowStatement = 243,

TryStatement = 244,

DebuggerStatement = 245,

VariableDeclaration = 246,

VariableDeclarationList = 247,

FunctionDeclaration = 248,

ClassDeclaration = 249,

InterfaceDeclaration = 250,

TypeAliasDeclaration = 251,

EnumDeclaration = 252,

ModuleDeclaration = 253,

ModuleBlock = 254,

CaseBlock = 255,

NamespaceExportDeclaration = 256,

ImportEqualsDeclaration = 257,

ImportDeclaration = 258,

ImportClause = 259,

NamespaceImport = 260,

NamedImports = 261,

ImportSpecifier = 262,

ExportAssignment = 263,

ExportDeclaration = 264,

NamedExports = 265,

NamespaceExport = 266,

ExportSpecifier = 267,

MissingDeclaration = 268,

ExternalModuleReference = 269,

JsxElement = 270,

JsxSelfClosingElement = 271,

JsxOpeningElement = 272,

JsxClosingElement = 273,

JsxFragment = 274,

JsxOpeningFragment = 275,

JsxClosingFragment = 276,

JsxAttribute = 277,

JsxAttributes = 278,

JsxSpreadAttribute = 279,

JsxExpression = 280,

CaseClause = 281,

DefaultClause = 282,

HeritageClause = 283,

CatchClause = 284,

PropertyAssignment = 285,

ShorthandPropertyAssignment = 286,

SpreadAssignment = 287,

EnumMember = 288,

UnparsedPrologue = 289,

UnparsedPrepend = 290,

UnparsedText = 291,

UnparsedInternalText = 292,

UnparsedSyntheticReference = 293,

SourceFile = 294,

Bundle = 295,

UnparsedSource = 296,

InputFiles = 297,

JSDocTypeExpression = 298,

JSDocAllType = 299,

JSDocUnknownType = 300,

JSDocNullableType = 301,

JSDocNonNullableType = 302,

JSDocOptionalType = 303,

JSDocFunctionType = 304,

JSDocVariadicType = 305,

JSDocNamepathType = 306,

JSDocComment = 307,

JSDocTypeLiteral = 308,

JSDocSignature = 309,

JSDocTag = 310,

JSDocAugmentsTag = 311,

JSDocImplementsTag = 312,

JSDocAuthorTag = 313,

JSDocDeprecatedTag = 314,

JSDocClassTag = 315,

JSDocPublicTag = 316,

JSDocPrivateTag = 317,

JSDocProtectedTag = 318,

JSDocReadonlyTag = 319,

JSDocCallbackTag = 320,

JSDocEnumTag = 321,

JSDocParameterTag = 322,

JSDocReturnTag = 323,

JSDocThisTag = 324,

JSDocTypeTag = 325,

JSDocTemplateTag = 326,

JSDocTypedefTag = 327,

JSDocPropertyTag = 328,

SyntaxList = 329,

NotEmittedStatement = 330,

PartiallyEmittedExpression = 331,

CommaListExpression = 332,

MergeDeclarationMarker = 333,

EndOfDeclarationMarker = 334,

SyntheticReferenceExpression = 335,

Count = 336,

FirstAssignment = 62,

LastAssignment = 77,

FirstCompoundAssignment = 63,

LastCompoundAssignment = 77,

FirstReservedWord = 80,

LastReservedWord = 115,

FirstKeyword = 80,

LastKeyword = 155,

FirstFutureReservedWord = 116,

LastFutureReservedWord = 124,

FirstTypeNode = 171,

LastTypeNode = 192,

FirstPunctuation = 18,

LastPunctuation = 77,

FirstToken = 0,

LastToken = 155,

FirstTriviaToken = 2,

LastTriviaToken = 7,

FirstLiteralToken = 8,

LastLiteralToken = 14,

FirstTemplateToken = 14,

LastTemplateToken = 17,

FirstBinaryOperator = 29,

LastBinaryOperator = 77,

FirstStatement = 229,

LastStatement = 245,

FirstNode = 156,

FirstJSDocNode = 298,

LastJSDocNode = 328,

FirstJSDocTagNode = 310,

LastJSDocTagNode = 328,

}

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.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.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.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.StaticKeyword;

export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | 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.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,

HasComputedFlags = 536870912,

AccessibilityModifier = 28,

ParameterPropertyModifier = 92,

NonPublicAccessibilityModifier = 24,

TypeScriptModifier = 2270,

ExportDefault = 513,

All = 11263

}

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 | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | LabeledStatement | ExpressionStatement | VariableStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | 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 {

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 StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;

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

export type ReadonlyToken = ReadonlyKeyword;

export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | 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

}

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

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, ObjectLiteralElement, JSDocContainer {

readonly kind: SyntaxKind.GetAccessor;

readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;

readonly name: PropertyName;

readonly body?: FunctionBody;

}

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

readonly kind: SyntaxKind.SetAccessor;

readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;

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 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 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 Expression extends Node {

_expressionBrand: any;

}

export interface OmittedExpression extends Expression {

readonly kind: SyntaxKind.OmittedExpression;

}

export interface PartiallyEmittedExpression extends LeftHandSideExpression {

readonly kind: SyntaxKind.PartiallyEmittedExpression;

readonly expression: Expression;

}

export interface UnaryExpression extends Expression {

_unaryExpressionBrand: any;

}

/** Deprecated, please use UpdateExpression */

export type IncrementExpression = UpdateExpression;

export interface UpdateExpression extends UnaryExpression {

_updateExpressionBrand: any;

}

export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;

export interface PrefixUnaryExpression extends UpdateExpression {

readonly kind: SyntaxKind.PrefixUnaryExpression;

readonly operator: PrefixUnaryOperator;

readonly operand: UnaryExpression;

}

export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;

export interface PostfixUnaryExpression extends UpdateExpression {

readonly kind: SyntaxKind.PostfixUnaryExpression;

readonly operand: LeftHandSideExpression;

readonly operator: PostfixUnaryOperator;

}

export interface LeftHandSideExpression extends UpdateExpression {

_leftHandSideExpressionBrand: any;

}

export interface MemberExpression extends LeftHandSideExpression {

_memberExpressionBrand: any;

}

export interface PrimaryExpression extends MemberExpression {

_primaryExpressionBrand: any;

}

export interface NullLiteral extends PrimaryExpression {

readonly kind: SyntaxKind.NullKeyword;

}

export interface TrueLiteral extends PrimaryExpression {

readonly kind: SyntaxKind.TrueKeyword;

}

export interface FalseLiteral extends PrimaryExpression {

readonly kind: SyntaxKind.FalseKeyword;

}

export type BooleanLiteral = TrueLiteral | FalseLiteral;

export interface ThisExpression extends PrimaryExpression {

readonly kind: SyntaxKind.ThisKeyword;

}

export interface SuperExpression extends PrimaryExpression {

readonly kind: SyntaxKind.SuperKeyword;

}

export interface ImportExpression extends PrimaryExpression {

readonly kind: SyntaxKind.ImportKeyword;

}

export interface DeleteExpression extends UnaryExpression {

readonly kind: SyntaxKind.DeleteExpression;

readonly expression: UnaryExpression;

}

export interface TypeOfExpression extends UnaryExpression {

readonly kind: SyntaxKind.TypeOfExpression;

readonly expression: UnaryExpression;

}

export interface VoidExpression extends UnaryExpression {

readonly kind: SyntaxKind.VoidExpression;

readonly expression: UnaryExpression;

}

export interface AwaitExpression extends UnaryExpression {

readonly kind: SyntaxKind.AwaitExpression;