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

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 {

/**

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

}

/** ES6 Map interface. */

interface Map<T> {

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]>;

}

/** ES6 Iterator type. */

interface Iterator<T> {

next(): {

value: T;

done: false;

} | {

value: never;

done: true;

};

}

type Path = string & {

__pathBrand: any;

};

interface FileMap<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;

}

interface TextRange {

pos: number;

end: number;

}

enum SyntaxKind {

Unknown = 0,

EndOfFileToken = 1,

SingleLineCommentTrivia = 2,

MultiLineCommentTrivia = 3,

NewLineTrivia = 4,

WhitespaceTrivia = 5,

ShebangTrivia = 6,

ConflictMarkerTrivia = 7,

NumericLiteral = 8,

StringLiteral = 9,

JsxText = 10,

RegularExpressionLiteral = 11,

NoSubstitutionTemplateLiteral = 12,

TemplateHead = 13,

TemplateMiddle = 14,

TemplateTail = 15,

OpenBraceToken = 16,

CloseBraceToken = 17,

OpenParenToken = 18,

CloseParenToken = 19,

OpenBracketToken = 20,

CloseBracketToken = 21,

DotToken = 22,

DotDotDotToken = 23,

SemicolonToken = 24,

CommaToken = 25,

LessThanToken = 26,

LessThanSlashToken = 27,

GreaterThanToken = 28,

LessThanEqualsToken = 29,

GreaterThanEqualsToken = 30,

EqualsEqualsToken = 31,

ExclamationEqualsToken = 32,

EqualsEqualsEqualsToken = 33,

ExclamationEqualsEqualsToken = 34,

EqualsGreaterThanToken = 35,

PlusToken = 36,

MinusToken = 37,

AsteriskToken = 38,

AsteriskAsteriskToken = 39,

SlashToken = 40,

PercentToken = 41,

PlusPlusToken = 42,

MinusMinusToken = 43,

LessThanLessThanToken = 44,

GreaterThanGreaterThanToken = 45,

GreaterThanGreaterThanGreaterThanToken = 46,

AmpersandToken = 47,

BarToken = 48,

CaretToken = 49,

ExclamationToken = 50,

TildeToken = 51,

AmpersandAmpersandToken = 52,

BarBarToken = 53,

QuestionToken = 54,

ColonToken = 55,

AtToken = 56,

EqualsToken = 57,

PlusEqualsToken = 58,

MinusEqualsToken = 59,

AsteriskEqualsToken = 60,

AsteriskAsteriskEqualsToken = 61,

SlashEqualsToken = 62,

PercentEqualsToken = 63,

LessThanLessThanEqualsToken = 64,

GreaterThanGreaterThanEqualsToken = 65,

GreaterThanGreaterThanGreaterThanEqualsToken = 66,

AmpersandEqualsToken = 67,

BarEqualsToken = 68,

CaretEqualsToken = 69,

Identifier = 70,

BreakKeyword = 71,

CaseKeyword = 72,

CatchKeyword = 73,

ClassKeyword = 74,

ConstKeyword = 75,

ContinueKeyword = 76,

DebuggerKeyword = 77,

DefaultKeyword = 78,

DeleteKeyword = 79,

DoKeyword = 80,

ElseKeyword = 81,

EnumKeyword = 82,

ExportKeyword = 83,

ExtendsKeyword = 84,

FalseKeyword = 85,

FinallyKeyword = 86,

ForKeyword = 87,

FunctionKeyword = 88,

IfKeyword = 89,

ImportKeyword = 90,

InKeyword = 91,

InstanceOfKeyword = 92,

NewKeyword = 93,

NullKeyword = 94,

ReturnKeyword = 95,

SuperKeyword = 96,

SwitchKeyword = 97,

ThisKeyword = 98,

ThrowKeyword = 99,

TrueKeyword = 100,

TryKeyword = 101,

TypeOfKeyword = 102,

VarKeyword = 103,

VoidKeyword = 104,

WhileKeyword = 105,

WithKeyword = 106,

ImplementsKeyword = 107,

InterfaceKeyword = 108,

LetKeyword = 109,

PackageKeyword = 110,

PrivateKeyword = 111,

ProtectedKeyword = 112,

PublicKeyword = 113,

StaticKeyword = 114,

YieldKeyword = 115,

AbstractKeyword = 116,

AsKeyword = 117,

AnyKeyword = 118,

AsyncKeyword = 119,

AwaitKeyword = 120,

BooleanKeyword = 121,

ConstructorKeyword = 122,

DeclareKeyword = 123,

GetKeyword = 124,

IsKeyword = 125,

KeyOfKeyword = 126,

ModuleKeyword = 127,

NamespaceKeyword = 128,

NeverKeyword = 129,

ReadonlyKeyword = 130,

RequireKeyword = 131,

NumberKeyword = 132,

ObjectKeyword = 133,

SetKeyword = 134,

StringKeyword = 135,

SymbolKeyword = 136,

TypeKeyword = 137,

UndefinedKeyword = 138,

FromKeyword = 139,

GlobalKeyword = 140,

OfKeyword = 141,

QualifiedName = 142,

ComputedPropertyName = 143,

TypeParameter = 144,

Parameter = 145,

Decorator = 146,

PropertySignature = 147,

PropertyDeclaration = 148,

MethodSignature = 149,

MethodDeclaration = 150,

Constructor = 151,

GetAccessor = 152,

SetAccessor = 153,

CallSignature = 154,

ConstructSignature = 155,

IndexSignature = 156,

TypePredicate = 157,

TypeReference = 158,

FunctionType = 159,

ConstructorType = 160,

TypeQuery = 161,

TypeLiteral = 162,

ArrayType = 163,

TupleType = 164,

UnionType = 165,

IntersectionType = 166,

ParenthesizedType = 167,

ThisType = 168,

TypeOperator = 169,

IndexedAccessType = 170,

MappedType = 171,

LiteralType = 172,

ObjectBindingPattern = 173,

ArrayBindingPattern = 174,

BindingElement = 175,

ArrayLiteralExpression = 176,

ObjectLiteralExpression = 177,

PropertyAccessExpression = 178,

ElementAccessExpression = 179,

CallExpression = 180,

NewExpression = 181,

TaggedTemplateExpression = 182,

TypeAssertionExpression = 183,

ParenthesizedExpression = 184,

FunctionExpression = 185,

ArrowFunction = 186,

DeleteExpression = 187,

TypeOfExpression = 188,

VoidExpression = 189,

AwaitExpression = 190,

PrefixUnaryExpression = 191,

PostfixUnaryExpression = 192,

BinaryExpression = 193,

ConditionalExpression = 194,

TemplateExpression = 195,

YieldExpression = 196,

SpreadElement = 197,

ClassExpression = 198,

OmittedExpression = 199,

ExpressionWithTypeArguments = 200,

AsExpression = 201,

NonNullExpression = 202,

MetaProperty = 203,

TemplateSpan = 204,

SemicolonClassElement = 205,

Block = 206,

VariableStatement = 207,

EmptyStatement = 208,

ExpressionStatement = 209,

IfStatement = 210,

DoStatement = 211,

WhileStatement = 212,

ForStatement = 213,

ForInStatement = 214,

ForOfStatement = 215,

ContinueStatement = 216,

BreakStatement = 217,

ReturnStatement = 218,

WithStatement = 219,

SwitchStatement = 220,

LabeledStatement = 221,

ThrowStatement = 222,

TryStatement = 223,

DebuggerStatement = 224,

VariableDeclaration = 225,

VariableDeclarationList = 226,

FunctionDeclaration = 227,

ClassDeclaration = 228,

InterfaceDeclaration = 229,

TypeAliasDeclaration = 230,

EnumDeclaration = 231,

ModuleDeclaration = 232,

ModuleBlock = 233,

CaseBlock = 234,

NamespaceExportDeclaration = 235,

ImportEqualsDeclaration = 236,

ImportDeclaration = 237,

ImportClause = 238,

NamespaceImport = 239,

NamedImports = 240,

ImportSpecifier = 241,

ExportAssignment = 242,

ExportDeclaration = 243,

NamedExports = 244,

ExportSpecifier = 245,

MissingDeclaration = 246,

ExternalModuleReference = 247,

JsxElement = 248,

JsxSelfClosingElement = 249,

JsxOpeningElement = 250,

JsxClosingElement = 251,

JsxAttribute = 252,

JsxAttributes = 253,

JsxSpreadAttribute = 254,

JsxExpression = 255,

CaseClause = 256,

DefaultClause = 257,

HeritageClause = 258,

CatchClause = 259,

PropertyAssignment = 260,

ShorthandPropertyAssignment = 261,

SpreadAssignment = 262,

EnumMember = 263,

SourceFile = 264,

Bundle = 265,

JSDocTypeExpression = 266,

JSDocAllType = 267,

JSDocUnknownType = 268,

JSDocArrayType = 269,

JSDocUnionType = 270,

JSDocTupleType = 271,

JSDocNullableType = 272,

JSDocNonNullableType = 273,

JSDocRecordType = 274,

JSDocRecordMember = 275,

JSDocTypeReference = 276,

JSDocOptionalType = 277,

JSDocFunctionType = 278,

JSDocVariadicType = 279,

JSDocConstructorType = 280,

JSDocThisType = 281,

JSDocComment = 282,

JSDocTag = 283,

JSDocAugmentsTag = 284,

JSDocParameterTag = 285,

JSDocReturnTag = 286,

JSDocTypeTag = 287,

JSDocTemplateTag = 288,

JSDocTypedefTag = 289,

JSDocPropertyTag = 290,

JSDocTypeLiteral = 291,

JSDocLiteralType = 292,

JSDocNullKeyword = 293,

JSDocUndefinedKeyword = 294,

JSDocNeverKeyword = 295,

SyntaxList = 296,

NotEmittedStatement = 297,

PartiallyEmittedExpression = 298,

MergeDeclarationMarker = 299,

EndOfDeclarationMarker = 300,

Count = 301,

FirstAssignment = 57,

LastAssignment = 69,

FirstCompoundAssignment = 58,

LastCompoundAssignment = 69,

FirstReservedWord = 71,

LastReservedWord = 106,

FirstKeyword = 71,

LastKeyword = 141,

FirstFutureReservedWord = 107,

LastFutureReservedWord = 115,

FirstTypeNode = 157,

LastTypeNode = 172,

FirstPunctuation = 16,

LastPunctuation = 69,

FirstToken = 0,

LastToken = 141,

FirstTriviaToken = 2,

LastTriviaToken = 7,

FirstLiteralToken = 8,

LastLiteralToken = 12,

FirstTemplateToken = 12,

LastTemplateToken = 15,

FirstBinaryOperator = 26,

LastBinaryOperator = 69,

FirstNode = 142,

FirstJSDocNode = 266,

LastJSDocNode = 295,

FirstJSDocTagNode = 282,

LastJSDocTagNode = 295,

}

enum NodeFlags {

None = 0,

Let = 1,

Const = 2,

NestedNamespace = 4,

Synthesized = 8,

Namespace = 16,

ExportContext = 32,

ContainsThis = 64,

HasImplicitReturn = 128,

HasExplicitReturn = 256,

GlobalAugmentation = 512,

HasAsyncFunctions = 1024,

DisallowInContext = 2048,

YieldContext = 4096,

DecoratorContext = 8192,

AwaitContext = 16384,

ThisNodeHasError = 32768,

JavaScriptFile = 65536,

ThisNodeOrAnySubNodesHasError = 131072,

HasAggregatedChildData = 262144,

BlockScoped = 3,

ReachabilityCheckFlags = 384,

ReachabilityAndEmitFlags = 1408,

ContextFlags = 96256,

TypeExcludesFlags = 20480,

}

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,

HasComputedFlags = 536870912,

AccessibilityModifier = 28,

ParameterPropertyModifier = 92,

NonPublicAccessibilityModifier = 24,

TypeScriptModifier = 2270,

ExportDefault = 513,

}

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,

}

interface Node extends TextRange {

kind: SyntaxKind;

flags: NodeFlags;

decorators?: NodeArray<Decorator>;

modifiers?: ModifiersArray;

parent?: Node;

}

interface NodeArray<T extends Node> extends Array<T>, TextRange {

hasTrailingComma?: boolean;

}

interface Token<TKind extends SyntaxKind> extends Node {

kind: TKind;

}

type DotDotDotToken = Token<SyntaxKind.DotDotDotToken>;

type QuestionToken = Token<SyntaxKind.QuestionToken>;

type ColonToken = Token<SyntaxKind.ColonToken>;

type EqualsToken = Token<SyntaxKind.EqualsToken>;

type AsteriskToken = Token<SyntaxKind.AsteriskToken>;

type EqualsGreaterThanToken = Token<SyntaxKind.EqualsGreaterThanToken>;

type EndOfFileToken = Token<SyntaxKind.EndOfFileToken>;

type AtToken = Token<SyntaxKind.AtToken>;

type ReadonlyToken = Token<SyntaxKind.ReadonlyKeyword>;

type Modifier = 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>;

type ModifiersArray = NodeArray<Modifier>;

interface Identifier extends PrimaryExpression {

kind: SyntaxKind.Identifier;

text: string;

originalKeywordKind?: SyntaxKind;

isInJSDocNamespace?: boolean;

}

interface TransientIdentifier extends Identifier {

resolvedSymbol: Symbol;

}

interface QualifiedName extends Node {

kind: SyntaxKind.QualifiedName;

left: EntityName;

right: Identifier;

}

type EntityName = Identifier | QualifiedName;

type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName;

type DeclarationName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | BindingPattern;

interface Declaration extends Node {

_declarationBrand: any;

name?: DeclarationName;

}

interface DeclarationStatement extends Declaration, Statement {

name?: Identifier | StringLiteral | NumericLiteral;

}

interface ComputedPropertyName extends Node {

kind: SyntaxKind.ComputedPropertyName;

expression: Expression;

}

interface Decorator extends Node {

kind: SyntaxKind.Decorator;

expression: LeftHandSideExpression;

}

interface TypeParameterDeclaration extends Declaration {

kind: SyntaxKind.TypeParameter;

name: Identifier;

constraint?: TypeNode;

default?: TypeNode;

expression?: Expression;

}

interface SignatureDeclaration extends Declaration {

name?: PropertyName;

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

}

interface CallSignatureDeclaration extends SignatureDeclaration, TypeElement {

kind: SyntaxKind.CallSignature;

}

interface ConstructSignatureDeclaration extends SignatureDeclaration, TypeElement {

kind: SyntaxKind.ConstructSignature;

}

type BindingName = Identifier | BindingPattern;

interface VariableDeclaration extends Declaration {

kind: SyntaxKind.VariableDeclaration;

parent?: VariableDeclarationList;

name: BindingName;

type?: TypeNode;

initializer?: Expression;

}

interface VariableDeclarationList extends Node {

kind: SyntaxKind.VariableDeclarationList;

declarations: NodeArray<VariableDeclaration>;

}

interface ParameterDeclaration extends Declaration {

kind: SyntaxKind.Parameter;

dotDotDotToken?: DotDotDotToken;

name: BindingName;

questionToken?: QuestionToken;

type?: TypeNode;

initializer?: Expression;

}

interface BindingElement extends Declaration {

kind: SyntaxKind.BindingElement;

propertyName?: PropertyName;

dotDotDotToken?: DotDotDotToken;

name: BindingName;

initializer?: Expression;

}

interface PropertySignature extends TypeElement {

kind: SyntaxKind.PropertySignature | SyntaxKind.JSDocRecordMember;

name: PropertyName;

questionToken?: QuestionToken;

type?: TypeNode;

initializer?: Expression;

}

interface PropertyDeclaration extends ClassElement {

kind: SyntaxKind.PropertyDeclaration;

questionToken?: QuestionToken;

name: PropertyName;

type?: TypeNode;

initializer?: Expression;

}

interface ObjectLiteralElement extends Declaration {

_objectLiteralBrandBrand: any;

name?: PropertyName;

}

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

interface PropertyAssignment extends ObjectLiteralElement {

kind: SyntaxKind.PropertyAssignment;

name: PropertyName;

questionToken?: QuestionToken;

initializer: Expression;

}

interface ShorthandPropertyAssignment extends ObjectLiteralElement {

kind: SyntaxKind.ShorthandPropertyAssignment;

name: Identifier;

questionToken?: QuestionToken;

equalsToken?: Token<SyntaxKind.EqualsToken>;

objectAssignmentInitializer?: Expression;

}

interface SpreadAssignment extends ObjectLiteralElement {

kind: SyntaxKind.SpreadAssignment;

expression: Expression;

}

interface VariableLikeDeclaration extends Declaration {

propertyName?: PropertyName;

dotDotDotToken?: DotDotDotToken;

name: DeclarationName;

questionToken?: QuestionToken;

type?: TypeNode;

initializer?: Expression;

}

interface PropertyLikeDeclaration extends Declaration {

name: PropertyName;

}

interface ObjectBindingPattern extends Node {

kind: SyntaxKind.ObjectBindingPattern;

elements: NodeArray<BindingElement>;

}

interface ArrayBindingPattern extends Node {

kind: SyntaxKind.ArrayBindingPattern;

elements: NodeArray<ArrayBindingElement>;

}

type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;

type ArrayBindingElement = BindingElement | OmittedExpression;

/**

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

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

* Examples:

* - FunctionDeclaration

* - MethodDeclaration

* - AccessorDeclaration

*/

interface FunctionLikeDeclaration extends SignatureDeclaration {

_functionLikeDeclarationBrand: any;

asteriskToken?: AsteriskToken;

questionToken?: QuestionToken;

body?: Block | Expression;

}

interface FunctionDeclaration extends FunctionLikeDeclaration, DeclarationStatement {

kind: SyntaxKind.FunctionDeclaration;

name?: Identifier;

body?: FunctionBody;

}

interface MethodSignature extends SignatureDeclaration, TypeElement {

kind: SyntaxKind.MethodSignature;

name: PropertyName;

}

interface MethodDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

kind: SyntaxKind.MethodDeclaration;

name: PropertyName;

body?: FunctionBody;

}

interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {

kind: SyntaxKind.Constructor;

body?: FunctionBody;

}

interface SemicolonClassElement extends ClassElement {

kind: SyntaxKind.SemicolonClassElement;

}

interface GetAccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

kind: SyntaxKind.GetAccessor;

name: PropertyName;

body: FunctionBody;

}

interface SetAccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

kind: SyntaxKind.SetAccessor;

name: PropertyName;

body: FunctionBody;

}

type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;

interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement, TypeElement {

kind: SyntaxKind.IndexSignature;

}

interface TypeNode extends Node {

_typeNodeBrand: any;

}

interface KeywordTypeNode extends TypeNode {

kind: SyntaxKind.AnyKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.VoidKeyword;

}

interface ThisTypeNode extends TypeNode {

kind: SyntaxKind.ThisType;

}

interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {

kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;

}

interface FunctionTypeNode extends FunctionOrConstructorTypeNode {

kind: SyntaxKind.FunctionType;

}

interface ConstructorTypeNode extends FunctionOrConstructorTypeNode {

kind: SyntaxKind.ConstructorType;

}

interface TypeReferenceNode extends TypeNode {

kind: SyntaxKind.TypeReference;

typeName: EntityName;

typeArguments?: NodeArray<TypeNode>;

}

interface TypePredicateNode extends TypeNode {

kind: SyntaxKind.TypePredicate;

parameterName: Identifier | ThisTypeNode;

type: TypeNode;

}

interface TypeQueryNode extends TypeNode {

kind: SyntaxKind.TypeQuery;

exprName: EntityName;

}

interface TypeLiteralNode extends TypeNode, Declaration {

kind: SyntaxKind.TypeLiteral;

members: NodeArray<TypeElement>;

}

interface ArrayTypeNode extends TypeNode {

kind: SyntaxKind.ArrayType;

elementType: TypeNode;

}

interface TupleTypeNode extends TypeNode {

kind: SyntaxKind.TupleType;

elementTypes: NodeArray<TypeNode>;

}

interface UnionOrIntersectionTypeNode extends TypeNode {

kind: SyntaxKind.UnionType | SyntaxKind.IntersectionType;

types: NodeArray<TypeNode>;

}

interface UnionTypeNode extends UnionOrIntersectionTypeNode {

kind: SyntaxKind.UnionType;

}

interface IntersectionTypeNode extends UnionOrIntersectionTypeNode {

kind: SyntaxKind.IntersectionType;

}

interface ParenthesizedTypeNode extends TypeNode {

kind: SyntaxKind.ParenthesizedType;

type: TypeNode;

}

interface TypeOperatorNode extends TypeNode {

kind: SyntaxKind.TypeOperator;

operator: SyntaxKind.KeyOfKeyword;

type: TypeNode;

}

interface IndexedAccessTypeNode extends TypeNode {

kind: SyntaxKind.IndexedAccessType;

objectType: TypeNode;

indexType: TypeNode;

}

interface MappedTypeNode extends TypeNode, Declaration {

kind: SyntaxKind.MappedType;

readonlyToken?: ReadonlyToken;

typeParameter: TypeParameterDeclaration;

questionToken?: QuestionToken;

type?: TypeNode;

}

interface LiteralTypeNode extends TypeNode {

kind: SyntaxKind.LiteralType;

literal: Expression;

}

interface StringLiteral extends LiteralExpression {

kind: SyntaxKind.StringLiteral;

}

interface Expression extends Node {

_expressionBrand: any;

contextualType?: Type;

}

interface OmittedExpression extends Expression {

kind: SyntaxKind.OmittedExpression;

}

interface PartiallyEmittedExpression extends LeftHandSideExpression {

kind: SyntaxKind.PartiallyEmittedExpression;

expression: Expression;

}

interface UnaryExpression extends Expression {

_unaryExpressionBrand: any;

}

interface IncrementExpression extends UnaryExpression {

_incrementExpressionBrand: any;

}

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

interface PrefixUnaryExpression extends IncrementExpression {

kind: SyntaxKind.PrefixUnaryExpression;

operator: PrefixUnaryOperator;

operand: UnaryExpression;

}

type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;

interface PostfixUnaryExpression extends IncrementExpression {

kind: SyntaxKind.PostfixUnaryExpression;

operand: LeftHandSideExpression;

operator: PostfixUnaryOperator;

}

interface LeftHandSideExpression extends IncrementExpression {

_leftHandSideExpressionBrand: any;

}

interface MemberExpression extends LeftHandSideExpression {

_memberExpressionBrand: any;

}

interface PrimaryExpression extends MemberExpression {

_primaryExpressionBrand: any;

}

interface NullLiteral extends PrimaryExpression {

kind: SyntaxKind.NullKeyword;

}

interface BooleanLiteral extends PrimaryExpression {

kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword;

}

interface ThisExpression extends PrimaryExpression {

kind: SyntaxKind.ThisKeyword;

}

interface SuperExpression extends PrimaryExpression {

kind: SyntaxKind.SuperKeyword;

}

interface DeleteExpression extends UnaryExpression {

kind: SyntaxKind.DeleteExpression;

expression: UnaryExpression;

}

interface TypeOfExpression extends UnaryExpression {

kind: SyntaxKind.TypeOfExpression;

expression: UnaryExpression;

}

interface VoidExpression extends UnaryExpression {

kind: SyntaxKind.VoidExpression;

expression: UnaryExpression;

}

interface AwaitExpression extends UnaryExpression {

kind: SyntaxKind.AwaitExpression;

expression: UnaryExpression;

}

interface YieldExpression extends Expression {

kind: SyntaxKind.YieldExpression;

asteriskToken?: AsteriskToken;

expression?: Expression;

}

type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken;

type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken;

type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator;

type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken;

type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator;

type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken;

type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator;

type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InstanceOfKeyword | SyntaxKind.InKeyword;

type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator;

type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken;

type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator;

type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken;

type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator;

type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken;

type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator;

type CompoundAssignmentOperator = SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken;

type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;

type AssignmentOperatorOrHigher = LogicalOperatorOrHigher | AssignmentOperator;

type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;

type BinaryOperatorToken = Token<BinaryOperator>;

interface BinaryExpression extends Expression, Declaration {

kind: SyntaxKind.BinaryExpression;

left: Expression;

operatorToken: BinaryOperatorToken;

right: Expression;

}

type AssignmentOperatorToken = Token<AssignmentOperator>;

interface AssignmentExpression<TOperator extends AssignmentOperatorToken> extends BinaryExpression {

left: LeftHandSideExpression;

operatorToken: TOperator;

}

interface ObjectDestructuringAssignment extends AssignmentExpression<EqualsToken> {

left: ObjectLiteralExpression;

}

interface ArrayDestructuringAssignment extends AssignmentExpression<EqualsToken> {

left: ArrayLiteralExpression;

}

type DestructuringAssignment = ObjectDestructuringAssignment | ArrayDestructuringAssignment;

type BindingOrAssignmentElement = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | OmittedExpression | SpreadElement | ArrayLiteralExpression | ObjectLiteralExpression | AssignmentExpression<EqualsToken> | Identifier | PropertyAccessExpression | ElementAccessExpression;

type BindingOrAssignmentElementRestIndicator = DotDotDotToken | SpreadElement | SpreadAssignment;

type BindingOrAssignmentElementTarget = BindingOrAssignmentPattern | Expression;

type ObjectBindingOrAssignmentPattern = ObjectBindingPattern | ObjectLiteralExpression;

type ArrayBindingOrAssignmentPattern = ArrayBindingPattern | ArrayLiteralExpression;

type AssignmentPattern = ObjectLiteralExpression | ArrayLiteralExpression;

type BindingOrAssignmentPattern = ObjectBindingOrAssignmentPattern | ArrayBindingOrAssignmentPattern;

interface ConditionalExpression extends Expression {

kind: SyntaxKind.ConditionalExpression;

condition: Expression;

questionToken: QuestionToken;

whenTrue: Expression;

colonToken: ColonToken;

whenFalse: Expression;

}

type FunctionBody = Block;

type ConciseBody = FunctionBody | Expression;

interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {

kind: SyntaxKind.FunctionExpression;

name?: Identifier;

body: FunctionBody;

}

interface ArrowFunction extends Expression, FunctionLikeDeclaration {

kind: SyntaxKind.ArrowFunction;

equalsGreaterThanToken: EqualsGreaterThanToken;

body: ConciseBody;

}

interface LiteralLikeNode extends Node {

text: string;

isUnterminated?: boolean;

hasExtendedUnicodeEscape?: boolean;

}

interface LiteralExpression extends LiteralLikeNode, PrimaryExpression {

_literalExpressionBrand: any;

}

interface RegularExpressionLiteral extends LiteralExpression {

kind: SyntaxKind.RegularExpressionLiteral;

}

interface NoSubstitutionTemplateLiteral extends LiteralExpression {

kind: SyntaxKind.NoSubstitutionTemplateLiteral;

}

interface NumericLiteral extends LiteralExpression {

kind: SyntaxKind.NumericLiteral;

trailingComment?: string;

}

interface TemplateHead extends LiteralLikeNode {

kind: SyntaxKind.TemplateHead;

}

interface TemplateMiddle extends LiteralLikeNode {

kind: SyntaxKind.TemplateMiddle;

}

interface TemplateTail extends LiteralLikeNode {

kind: SyntaxKind.TemplateTail;

}

type TemplateLiteral = TemplateExpression | NoSubstitutionTemplateLiteral;

interface TemplateExpression extends PrimaryExpression {

kind: SyntaxKind.TemplateExpression;

head: TemplateHead;

templateSpans: NodeArray<TemplateSpan>;

}

interface TemplateSpan extends Node {

kind: SyntaxKind.TemplateSpan;

expression: Expression;

literal: TemplateMiddle | TemplateTail;

}

interface ParenthesizedExpression extends PrimaryExpression {

kind: SyntaxKind.ParenthesizedExpression;

expression: Expression;

}

interface ArrayLiteralExpression extends PrimaryExpression {

kind: SyntaxKind.ArrayLiteralExpression;

elements: NodeArray<Expression>;

}

interface SpreadElement extends Expression {

kind: SyntaxKind.SpreadElement;

expression: Expression;

}

/**

* This interface is a base interface for ObjectLiteralExpression and JSXAttributes to extend from. JSXAttributes is similar to

* ObjectLiteralExpression in that it contains array of properties; however, JSXAttributes' properties can only be

* JSXAttribute or JSXSpreadAttribute. ObjectLiteralExpression, on the other hand, can only have properties of type

* ObjectLiteralElement (e.g. PropertyAssignment, ShorthandPropertyAssignment etc.)

**/

interface ObjectLiteralExpressionBase<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {

properties: NodeArray<T>;

}

interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike> {

kind: SyntaxKind.ObjectLiteralExpression;

}

type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression;

type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression;

interface PropertyAccessExpression extends MemberExpression, Declaration {

kind: SyntaxKind.PropertyAccessExpression;

expression: LeftHandSideExpression;

name: Identifier;

}

interface SuperPropertyAccessExpression extends PropertyAccessExpression {

expression: SuperExpression;

}

/** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */

interface PropertyAccessEntityNameExpression extends PropertyAccessExpression {

_propertyAccessExpressionLikeQualifiedNameBrand?: any;

expression: EntityNameExpression;

}

interface ElementAccessExpression extends MemberExpression {

kind: SyntaxKind.ElementAccessExpression;

expression: LeftHandSideExpression;

argumentExpression?: Expression;

}

interface SuperElementAccessExpression extends ElementAccessExpression {

expression: SuperExpression;

}

type SuperProperty = SuperPropertyAccessExpression | SuperElementAccessExpression;

interface CallExpression extends LeftHandSideExpression, Declaration {

kind: SyntaxKind.CallExpression;

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

}

interface SuperCall extends CallExpression {

expression: SuperExpression;

}

interface ExpressionWithTypeArguments extends TypeNode {

kind: SyntaxKind.ExpressionWithTypeArguments;

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

}

interface NewExpression extends PrimaryExpression, Declaration {

kind: SyntaxKind.NewExpression;

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

}

interface TaggedTemplateExpression extends MemberExpression {

kind: SyntaxKind.TaggedTemplateExpression;

tag: LeftHandSideExpression;

template: TemplateLiteral;

}

type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression | Decorator | JsxOpeningLikeElement;

interface AsExpression extends Expression {

kind: SyntaxKind.AsExpression;

expression: Expression;

type: TypeNode;

}

interface TypeAssertion extends UnaryExpression {

kind: SyntaxKind.TypeAssertionExpression;

type: TypeNode;

expression: UnaryExpression;

}

type AssertionExpression = TypeAssertion | AsExpression;