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.

*/

export interface MapLike<T> {

[index: string]: T;

}

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

export 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. */

export interface Map<T> extends ReadonlyMap<T> {

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

delete(key: string): boolean;

clear(): void;

}

/** ES6 Iterator type. */

export interface Iterator<T> {

next(): { value: T, done: false } | { value: never, done: true };

}

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

export interface Push<T> {

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

}

/* @internal */

export type EqualityComparer<T> = (a: T, b: T) => boolean;

/* @internal */

export type Comparer<T> = (a: T, b: T) => Comparison;

/* @internal */

export const enum Comparison {

LessThan = -1,

EqualTo = 0,

GreaterThan = 1

}

// branded string type used to store absolute, normalized and canonicalized paths

// arbitrary file name can be converted to Path via toPath function

export type Path = string & { __pathBrand: any };

export interface TextRange {

pos: number;

end: number;

}

export type JsDocSyntaxKind =

| SyntaxKind.EndOfFileToken

| SyntaxKind.WhitespaceTrivia

| SyntaxKind.AtToken

| SyntaxKind.NewLineTrivia

| SyntaxKind.AsteriskToken

| SyntaxKind.OpenBraceToken

| SyntaxKind.CloseBraceToken

| SyntaxKind.LessThanToken

| SyntaxKind.OpenBracketToken

| SyntaxKind.CloseBracketToken

| SyntaxKind.EqualsToken

| SyntaxKind.CommaToken

| SyntaxKind.DotToken

| SyntaxKind.Identifier

| SyntaxKind.Unknown;

// token > SyntaxKind.Identifer => token is a keyword

// Also, If you add a new SyntaxKind be sure to keep the `Markers` section at the bottom in sync

export const enum SyntaxKind {

Unknown,

EndOfFileToken,

SingleLineCommentTrivia,

MultiLineCommentTrivia,

NewLineTrivia,

WhitespaceTrivia,

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

ShebangTrivia,

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

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

ConflictMarkerTrivia,

// Literals

NumericLiteral,

StringLiteral,

JsxText,

JsxTextAllWhiteSpaces,

RegularExpressionLiteral,

NoSubstitutionTemplateLiteral,

// Pseudo-literals

TemplateHead,

TemplateMiddle,

TemplateTail,

// Punctuation

OpenBraceToken,

CloseBraceToken,

OpenParenToken,

CloseParenToken,

OpenBracketToken,

CloseBracketToken,

DotToken,

DotDotDotToken,

SemicolonToken,

CommaToken,

LessThanToken,

LessThanSlashToken,

GreaterThanToken,

LessThanEqualsToken,

GreaterThanEqualsToken,

EqualsEqualsToken,

ExclamationEqualsToken,

EqualsEqualsEqualsToken,

ExclamationEqualsEqualsToken,

EqualsGreaterThanToken,

PlusToken,

MinusToken,

AsteriskToken,

AsteriskAsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

AsteriskAsteriskEqualsToken,

SlashEqualsToken,

PercentEqualsToken,

LessThanLessThanEqualsToken,

GreaterThanGreaterThanEqualsToken,

GreaterThanGreaterThanGreaterThanEqualsToken,

AmpersandEqualsToken,

BarEqualsToken,

CaretEqualsToken,

// Identifiers

Identifier,

// Reserved words

BreakKeyword,

CaseKeyword,

CatchKeyword,

ClassKeyword,

ConstKeyword,

ContinueKeyword,

DebuggerKeyword,

DefaultKeyword,

DeleteKeyword,

DoKeyword,

ElseKeyword,

EnumKeyword,

ExportKeyword,

ExtendsKeyword,

FalseKeyword,

FinallyKeyword,

ForKeyword,

FunctionKeyword,

IfKeyword,

ImportKeyword,

InKeyword,

InstanceOfKeyword,

NewKeyword,

NullKeyword,

ReturnKeyword,

SuperKeyword,

SwitchKeyword,

ThisKeyword,

ThrowKeyword,

TrueKeyword,

TryKeyword,

TypeOfKeyword,

VarKeyword,

VoidKeyword,

WhileKeyword,

WithKeyword,

// Strict mode reserved words

ImplementsKeyword,

InterfaceKeyword,

LetKeyword,

PackageKeyword,

PrivateKeyword,

ProtectedKeyword,

PublicKeyword,

StaticKeyword,

YieldKeyword,

// Contextual keywords

AbstractKeyword,

AsKeyword,

AnyKeyword,

AsyncKeyword,

AwaitKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

InferKeyword,

IsKeyword,

KeyOfKeyword,

ModuleKeyword,

NamespaceKeyword,

NeverKeyword,

ReadonlyKeyword,

RequireKeyword,

NumberKeyword,

ObjectKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

UndefinedKeyword,

UniqueKeyword,

FromKeyword,

GlobalKeyword,

OfKeyword, // LastKeyword and LastToken and LastContextualKeyword

// Parse tree nodes

// Names

QualifiedName,

ComputedPropertyName,

// Signature elements

TypeParameter,

Parameter,

Decorator,

// TypeMember

PropertySignature,

PropertyDeclaration,

MethodSignature,

MethodDeclaration,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypePredicate,

TypeReference,

FunctionType,

ConstructorType,

TypeQuery,

TypeLiteral,

ArrayType,

TupleType,

UnionType,

IntersectionType,

ConditionalType,

InferType,

ParenthesizedType,

ThisType,

TypeOperator,

IndexedAccessType,

MappedType,

LiteralType,

// Binding patterns

ObjectBindingPattern,

ArrayBindingPattern,

BindingElement,

// Expression

ArrayLiteralExpression,

ObjectLiteralExpression,

PropertyAccessExpression,

ElementAccessExpression,

CallExpression,

NewExpression,

TaggedTemplateExpression,

TypeAssertionExpression,

ParenthesizedExpression,

FunctionExpression,

ArrowFunction,

DeleteExpression,

TypeOfExpression,

VoidExpression,

AwaitExpression,

PrefixUnaryExpression,

PostfixUnaryExpression,

BinaryExpression,

ConditionalExpression,

TemplateExpression,

YieldExpression,

SpreadElement,

ClassExpression,

OmittedExpression,

ExpressionWithTypeArguments,

AsExpression,

NonNullExpression,

MetaProperty,

// Misc

TemplateSpan,

SemicolonClassElement,

// Element

Block,

VariableStatement,

EmptyStatement,

ExpressionStatement,

IfStatement,

DoStatement,

WhileStatement,

ForStatement,

ForInStatement,

ForOfStatement,

ContinueStatement,

BreakStatement,

ReturnStatement,

WithStatement,

SwitchStatement,

LabeledStatement,

ThrowStatement,

TryStatement,

DebuggerStatement,

VariableDeclaration,

VariableDeclarationList,

FunctionDeclaration,

ClassDeclaration,

InterfaceDeclaration,

TypeAliasDeclaration,

EnumDeclaration,

ModuleDeclaration,

ModuleBlock,

CaseBlock,

NamespaceExportDeclaration,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// JSX

JsxElement,

JsxSelfClosingElement,

JsxOpeningElement,

JsxClosingElement,

JsxFragment,

JsxOpeningFragment,

JsxClosingFragment,

JsxAttribute,

JsxAttributes,

JsxSpreadAttribute,

JsxExpression,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

SpreadAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

Bundle,

// JSDoc nodes

JSDocTypeExpression,

// The * type

JSDocAllType,

// The ? type

JSDocUnknownType,

JSDocNullableType,

JSDocNonNullableType,

JSDocOptionalType,

JSDocFunctionType,

JSDocVariadicType,

JSDocComment,

JSDocTypeLiteral,

JSDocTag,

JSDocAugmentsTag,

JSDocClassTag,

JSDocParameterTag,

JSDocReturnTag,

JSDocTypeTag,

JSDocTemplateTag,

JSDocTypedefTag,

JSDocPropertyTag,

// Synthesized list

SyntaxList,

// Transformation nodes

NotEmittedStatement,

PartiallyEmittedExpression,

CommaListExpression,

MergeDeclarationMarker,

EndOfDeclarationMarker,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstCompoundAssignment = PlusEqualsToken,

LastCompoundAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypePredicate,

LastTypeNode = LiteralType,

FirstPunctuation = OpenBraceToken,

LastPunctuation = CaretEqualsToken,

FirstToken = Unknown,

LastToken = LastKeyword,

FirstTriviaToken = SingleLineCommentTrivia,

LastTriviaToken = ConflictMarkerTrivia,

FirstLiteralToken = NumericLiteral,

LastLiteralToken = NoSubstitutionTemplateLiteral,

FirstTemplateToken = NoSubstitutionTemplateLiteral,

LastTemplateToken = TemplateTail,

FirstBinaryOperator = LessThanToken,

LastBinaryOperator = CaretEqualsToken,

FirstNode = QualifiedName,

FirstJSDocNode = JSDocTypeExpression,

LastJSDocNode = JSDocPropertyTag,

FirstJSDocTagNode = JSDocTag,

LastJSDocTagNode = JSDocPropertyTag,

/* @internal */ FirstContextualKeyword = AbstractKeyword,

/* @internal */ LastContextualKeyword = OfKeyword,

}

export const enum NodeFlags {

None = 0,

Let = 1 << 0, // Variable declaration

Const = 1 << 1, // Variable declaration

NestedNamespace = 1 << 2, // Namespace declaration

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

Namespace = 1 << 4, // Namespace declaration

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

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

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

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

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

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

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

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

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

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

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

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

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

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

// This flag will be set when the parser encounters a dynamic import expression so that module resolution

// will not have to walk the tree if the flag is not set. However, this flag is just a approximation because

// once it is set, the flag never gets cleared (hence why it's named "PossiblyContainsDynamicImport").

// During editing, if dynamic import is removed, incremental parsing will *NOT* update this flag. This means that the tree will always be traversed

// during module resolution. However, the removal operation should not occur often and in the case of the

// removal, it is likely that users will add the import anyway.

// The advantage of this approach is its simplicity. For the case of batch compilation,

// we guarantee that users won't have to pay the price of walking the tree if a dynamic import isn't used.

/* @internal */

PossiblyContainsDynamicImport = 1 << 19,

JSDoc = 1 << 20, // If node was parsed inside jsdoc

/* @internal */ Ambient = 1 << 21, // If node was inside an ambient context -- a declaration file, or inside something with the `declare` modifier.

/* @internal */ InWithStatement = 1 << 22, // If any ancestor of node was the `statement` of a WithStatement (not the `expression`)

BlockScoped = Let | Const,

ReachabilityCheckFlags = HasImplicitReturn | HasExplicitReturn,

ReachabilityAndEmitFlags = ReachabilityCheckFlags | HasAsyncFunctions,

// Parsing context flags

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

// Exclude these flags when parsing a Type

TypeExcludesFlags = YieldContext | AwaitContext,

}

export const enum ModifierFlags {

None = 0,

Export = 1 << 0, // Declarations

Ambient = 1 << 1, // Declarations

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

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

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

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

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

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

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

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

Const = 1 << 11, // Variable declaration

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

AccessibilityModifier = Public | Private | Protected,

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

ParameterPropertyModifier = AccessibilityModifier | Readonly,

NonPublicAccessibilityModifier = Private | Protected,

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

ExportDefault = Export | Default,

}

export const enum JsxFlags {

None = 0,

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

IntrinsicNamedElement = 1 << 0,

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

IntrinsicIndexedElement = 1 << 1,

IntrinsicElement = IntrinsicNamedElement | IntrinsicIndexedElement,

}

/* @internal */

export const enum RelationComparisonResult {

Succeeded = 1, // Should be truthy

Failed = 2,

FailedAndReported = 3

}

export interface Node extends TextRange {

kind: SyntaxKind;

flags: NodeFlags;

/* @internal */ modifierFlagsCache?: ModifierFlags;

/* @internal */ transformFlags?: TransformFlags;

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

modifiers?: ModifiersArray; // Array of modifiers

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

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

/* @internal */ original?: Node; // The original node if this is an updated node.

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

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

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

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

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

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

/* @internal */ contextualType?: Type; // Used to temporarily assign a contextual type during overload resolution

/* @internal */ contextualMapper?: TypeMapper; // Mapper for contextual type

}

export interface JSDocContainer {

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

/* @internal */ jsDocCache?: ReadonlyArray<JSDocTag>; // Cache for getJSDocTags

}

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

| IndexSignatureDeclaration

| FunctionTypeNode

| ConstructorTypeNode

| JSDocFunctionType

| EndOfFileToken;

export type HasType =

| SignatureDeclaration

| VariableDeclaration

| ParameterDeclaration

| PropertySignature

| PropertyDeclaration

| TypePredicateNode

| ParenthesizedTypeNode

| TypeOperatorNode

| MappedTypeNode

| AssertionExpression

| TypeAliasDeclaration

| JSDocTypeExpression

| JSDocNonNullableType

| JSDocNullableType

| JSDocOptionalType

| JSDocVariadicType;

export type HasInitializer =

| HasExpressionInitializer

| ForStatement

| ForInStatement

| ForOfStatement

| JsxAttribute;

export type HasExpressionInitializer =

| VariableDeclaration

| ParameterDeclaration

| BindingElement

| PropertySignature

| PropertyDeclaration

| PropertyAssignment

| EnumMember;

/* @internal */

export type MutableNodeArray<T extends Node> = NodeArray<T> & T[];

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

hasTrailingComma?: boolean;

/* @internal */ transformFlags?: TransformFlags;

}

export interface Token<TKind extends SyntaxKind> extends Node {

kind: TKind;

}

export type DotDotDotToken = Token<SyntaxKind.DotDotDotToken>;

export type QuestionToken = Token<SyntaxKind.QuestionToken>;

export type ExclamationToken = Token<SyntaxKind.ExclamationToken>;

export type ColonToken = Token<SyntaxKind.ColonToken>;

export type EqualsToken = Token<SyntaxKind.EqualsToken>;

export type AsteriskToken = Token<SyntaxKind.AsteriskToken>;

export type EqualsGreaterThanToken = Token<SyntaxKind.EqualsGreaterThanToken>;

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

export type AtToken = Token<SyntaxKind.AtToken>;

export type ReadonlyToken = Token<SyntaxKind.ReadonlyKeyword>;

export type AwaitKeywordToken = Token<SyntaxKind.AwaitKeyword>;

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

;

export type ModifiersArray = NodeArray<Modifier>;

/*@internal*/

export const enum GeneratedIdentifierFlags {

// Kinds

None = 0, // Not automatically generated.

Auto = 1, // Automatically generated identifier.

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

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

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

KindMask = 7, // Mask to extract the kind of identifier from its flags.

// Flags

SkipNameGenerationScope = 1 << 3, // Should skip a name generation scope when generating the name for this identifier

ReservedInNestedScopes = 1 << 4, // Reserve the generated name in nested scopes

}

export interface Identifier extends PrimaryExpression, Declaration {

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.

*/

escapedText: __String;

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

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

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

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

/*@internal*/ typeArguments?: NodeArray<TypeNode | TypeParameterDeclaration>; // Only defined on synthesized nodes. Though not syntactically valid, used in emitting diagnostics, quickinfo, and signature help.

/*@internal*/ jsdocDotPos?: number; // Identifier occurs in JSDoc-style generic: Id.<T>

}

// Transient identifier node (marked by id === -1)

export interface TransientIdentifier extends Identifier {

resolvedSymbol: Symbol;

}

/*@internal*/

export interface GeneratedIdentifier extends Identifier {

autoGenerateFlags: GeneratedIdentifierFlags;

}

export interface QualifiedName extends Node {

kind: SyntaxKind.QualifiedName;

left: EntityName;

right: Identifier;

/*@internal*/ jsdocDotPos?: number; // QualifiedName occurs in JSDoc-style generic: Id1.Id2.<T>

}

export type EntityName = Identifier | QualifiedName;

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

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

export interface Declaration extends Node {

_declarationBrand: any;

}

export interface NamedDeclaration extends Declaration {

name?: DeclarationName;

}

/* @internal */

export interface DynamicNamedDeclaration extends NamedDeclaration {

name: ComputedPropertyName;

}

/* @internal */

// A declaration that supports late-binding (used in checker)

export interface LateBoundDeclaration extends DynamicNamedDeclaration {

name: LateBoundName;

}

export interface DeclarationStatement extends NamedDeclaration, Statement {

name?: Identifier | StringLiteral | NumericLiteral;

}

export interface ComputedPropertyName extends Node {

kind: SyntaxKind.ComputedPropertyName;

expression: Expression;

}

/* @internal */

// A name that supports late-binding (used in checker)

export interface LateBoundName extends ComputedPropertyName {

expression: EntityNameExpression;

}

export interface Decorator extends Node {

kind: SyntaxKind.Decorator;

parent?: NamedDeclaration;

expression: LeftHandSideExpression;

}

export interface TypeParameterDeclaration extends NamedDeclaration {

kind: SyntaxKind.TypeParameter;

parent?: DeclarationWithTypeParameters | InferTypeNode;

name: Identifier;

constraint?: TypeNode;

default?: TypeNode;

// For error recovery purposes.

expression?: Expression;

}

export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {

kind: SignatureDeclaration["kind"];

name?: PropertyName;

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type: TypeNode | undefined;

/* @internal */ typeArguments?: NodeArray<TypeNode>; // Used for quick info, replaces typeParameters for instantiated signatures

}

export type SignatureDeclaration =

| CallSignatureDeclaration

| ConstructSignatureDeclaration

| MethodSignature

| IndexSignatureDeclaration

| FunctionTypeNode

| ConstructorTypeNode

| JSDocFunctionType

| FunctionDeclaration

| MethodDeclaration

| ConstructorDeclaration

| AccessorDeclaration

| FunctionExpression

| ArrowFunction;

export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {

kind: SyntaxKind.CallSignature;

}

export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement {

kind: SyntaxKind.ConstructSignature;

}

export type BindingName = Identifier | BindingPattern;

export interface VariableDeclaration extends NamedDeclaration {

kind: SyntaxKind.VariableDeclaration;

parent?: VariableDeclarationList | CatchClause;

name: BindingName; // Declared variable name

exclamationToken?: ExclamationToken; // Optional definite assignment assertion

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface VariableDeclarationList extends Node {

kind: SyntaxKind.VariableDeclarationList;

parent?: VariableStatement | ForStatement | ForOfStatement | ForInStatement;

declarations: NodeArray<VariableDeclaration>;

}

export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {

kind: SyntaxKind.Parameter;

parent?: SignatureDeclaration;

dotDotDotToken?: DotDotDotToken; // Present on rest parameter

name: BindingName; // Declared parameter name.

questionToken?: QuestionToken; // Present on optional parameter

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface BindingElement extends NamedDeclaration {

kind: SyntaxKind.BindingElement;

parent?: BindingPattern;

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

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

name: BindingName; // Declared binding element name

initializer?: Expression; // Optional initializer

}

/*@internal*/

export type BindingElementGrandparent = BindingElement["parent"]["parent"];

export interface PropertySignature extends TypeElement, JSDocContainer {

kind: SyntaxKind.PropertySignature;

name: PropertyName; // Declared property name

questionToken?: QuestionToken; // Present on optional property

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface PropertyDeclaration extends ClassElement, JSDocContainer {

kind: SyntaxKind.PropertyDeclaration;

name: PropertyName;

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

exclamationToken?: ExclamationToken;

type?: TypeNode;

initializer?: Expression; // Optional initializer

}

export interface ObjectLiteralElement extends NamedDeclaration {

_objectLiteralBrandBrand: any;

name?: PropertyName;

}

export type ObjectLiteralElementLike

= PropertyAssignment

| ShorthandPropertyAssignment

| SpreadAssignment

| MethodDeclaration

| AccessorDeclaration

;

export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {

parent: ObjectLiteralExpression;

kind: SyntaxKind.PropertyAssignment;

name: PropertyName;

questionToken?: QuestionToken;

initializer: Expression;

}

export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {

parent: ObjectLiteralExpression;

kind: SyntaxKind.ShorthandPropertyAssignment;

name: Identifier;

questionToken?: QuestionToken;

// used when ObjectLiteralExpression is used in ObjectAssignmentPattern

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

equalsToken?: Token<SyntaxKind.EqualsToken>;

objectAssignmentInitializer?: Expression;

}

export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {

parent: ObjectLiteralExpression;

kind: SyntaxKind.SpreadAssignment;

expression: Expression;

}

export type VariableLikeDeclaration =

| VariableDeclaration

| ParameterDeclaration

| BindingElement

| PropertyDeclaration

| PropertyAssignment

| PropertySignature

| JsxAttribute

| ShorthandPropertyAssignment

| EnumMember

| JSDocPropertyTag

| JSDocParameterTag;

export interface PropertyLikeDeclaration extends NamedDeclaration {

name: PropertyName;

}

export interface ObjectBindingPattern extends Node {

kind: SyntaxKind.ObjectBindingPattern;

parent?: VariableDeclaration | ParameterDeclaration | BindingElement;

elements: NodeArray<BindingElement>;

}

export interface ArrayBindingPattern extends Node {

kind: SyntaxKind.ArrayBindingPattern;

parent?: VariableDeclaration | ParameterDeclaration | BindingElement;

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;

asteriskToken?: AsteriskToken;

questionToken?: QuestionToken;

body?: Block | Expression;

}

export type FunctionLikeDeclaration =

| FunctionDeclaration

| MethodDeclaration

| ConstructorDeclaration

| GetAccessorDeclaration

| SetAccessorDeclaration

| FunctionExpression

| ArrowFunction;

export type FunctionLike =

| FunctionLikeDeclaration

| FunctionTypeNode

| ConstructorTypeNode

| IndexSignatureDeclaration

| MethodSignature

| ConstructSignatureDeclaration

| CallSignatureDeclaration

| JSDocFunctionType;

export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement {

kind: SyntaxKind.FunctionDeclaration;

name?: Identifier;

body?: FunctionBody;

}

export interface MethodSignature extends SignatureDeclarationBase, TypeElement {

kind: SyntaxKind.MethodSignature;

name: PropertyName;

}

// Note that a MethodDeclaration is considered both a ClassElement and an ObjectLiteralElement.

// Both the grammars for ClassDeclaration and ObjectLiteralExpression allow for MethodDeclarations

// as child elements, and so a MethodDeclaration satisfies both interfaces. This avoids the

// alternative where we would need separate kinds/types for ClassMethodDeclaration and

// ObjectLiteralMethodDeclaration, which would look identical.

//

// Because of this, it may be necessary to determine what sort of MethodDeclaration you have

// at later stages of the compiler pipeline. In that case, you can either check the parent kind

// of the method, or use helpers like isObjectLiteralMethodDeclaration

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

kind: SyntaxKind.MethodDeclaration;

name: PropertyName;