export interface Map<T> {

[index: string]: T;

}

export interface TextRange {

pos: number;

end: number;

}

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

export const enum SyntaxKind {

Unknown,

EndOfFileToken,

SingleLineCommentTrivia,

MultiLineCommentTrivia,

NewLineTrivia,

WhitespaceTrivia,

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

RegularExpressionLiteral,

NoSubstitutionTemplateLiteral,

// Pseudo-literals

TemplateHead,

TemplateMiddle,

TemplateTail,

// Punctuation

OpenBraceToken,

CloseBraceToken,

OpenParenToken,

CloseParenToken,

OpenBracketToken,

CloseBracketToken,

DotToken,

DotDotDotToken,

SemicolonToken,

CommaToken,

LessThanToken,

GreaterThanToken,

LessThanEqualsToken,

GreaterThanEqualsToken,

EqualsEqualsToken,

ExclamationEqualsToken,

EqualsEqualsEqualsToken,

ExclamationEqualsEqualsToken,

EqualsGreaterThanToken,

PlusToken,

MinusToken,

AsteriskToken,

SlashToken,

PercentToken,

PlusPlusToken,

MinusMinusToken,

LessThanLessThanToken,

GreaterThanGreaterThanToken,

GreaterThanGreaterThanGreaterThanToken,

AmpersandToken,

BarToken,

CaretToken,

ExclamationToken,

TildeToken,

AmpersandAmpersandToken,

BarBarToken,

QuestionToken,

ColonToken,

AtToken,

// Assignments

EqualsToken,

PlusEqualsToken,

MinusEqualsToken,

AsteriskEqualsToken,

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

AsKeyword,

AnyKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

ModuleKeyword,

RequireKeyword,

NumberKeyword,

SetKeyword,

StringKeyword,

SymbolKeyword,

TypeKeyword,

FromKeyword,

OfKeyword, // LastKeyword and LastToken

// Parse tree nodes

// Names

QualifiedName,

ComputedPropertyName,

// Signature elements

TypeParameter,

Parameter,

Decorator,

// TypeMember

PropertySignature,

PropertyDeclaration,

MethodSignature,

MethodDeclaration,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypeReference,

FunctionType,

ConstructorType,

TypeQuery,

TypeLiteral,

ArrayType,

TupleType,

UnionType,

ParenthesizedType,

// Binding patterns

ObjectBindingPattern,

ArrayBindingPattern,

BindingElement,

// Expression

ArrayLiteralExpression,

ObjectLiteralExpression,

PropertyAccessExpression,

ElementAccessExpression,

CallExpression,

NewExpression,

TaggedTemplateExpression,

TypeAssertionExpression,

ParenthesizedExpression,

FunctionExpression,

ArrowFunction,

DeleteExpression,

TypeOfExpression,

VoidExpression,

PrefixUnaryExpression,

PostfixUnaryExpression,

BinaryExpression,

ConditionalExpression,

TemplateExpression,

YieldExpression,

SpreadElementExpression,

ClassExpression,

OmittedExpression,

// Misc

TemplateSpan,

HeritageClauseElement,

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,

ImportEqualsDeclaration,

ImportDeclaration,

ImportClause,

NamespaceImport,

NamedImports,

ImportSpecifier,

ExportAssignment,

ExportDeclaration,

NamedExports,

ExportSpecifier,

MissingDeclaration,

// Module references

ExternalModuleReference,

// Clauses

CaseClause,

DefaultClause,

HeritageClause,

CatchClause,

// Property assignments

PropertyAssignment,

ShorthandPropertyAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

// Synthesized list

SyntaxList,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = OfKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword,

FirstTypeNode = TypeReference,

LastTypeNode = ParenthesizedType,

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,

}

export const enum NodeFlags {

Export = 0x00000001, // Declarations

Ambient = 0x00000002, // Declarations

Public = 0x00000010, // Property/Method

Private = 0x00000020, // Property/Method

Protected = 0x00000040, // Property/Method

Static = 0x00000080, // Property/Method

Default = 0x00000100, // Function/Class (export default declaration)

MultiLine = 0x00000200, // Multi-line array or object literal

Synthetic = 0x00000400, // Synthetic node (for full fidelity)

DeclarationFile = 0x00000800, // Node is a .d.ts file

Let = 0x00001000, // Variable declaration

Const = 0x00002000, // Variable declaration

OctalLiteral = 0x00004000,

ExportContext = 0x00008000, // Export context (initialized by binding)

Modifier = Export | Ambient | Public | Private | Protected | Static | Default,

AccessibilityModifier = Public | Private | Protected,

BlockScoped = Let | Const

}

/* @internal */

export const enum ParserContextFlags {

// Set if this node was parsed in strict mode. Used for grammar error checks, as well as

// checking if the node can be reused in incremental settings.

StrictMode = 1 << 0,

// If this node was parsed in a context where 'in-expressions' are not allowed.

DisallowIn = 1 << 1,

// If this node was parsed in the 'yield' context created when parsing a generator.

Yield = 1 << 2,

// If this node was parsed in the parameters of a generator.

GeneratorParameter = 1 << 3,

// If this node was parsed as part of a decorator

Decorator = 1 << 4,

// If the parser encountered an error when parsing the code that created this node. Note

// the parser only sets this directly on the node it creates right after encountering the

// error.

ThisNodeHasError = 1 << 5,

// Context flags set directly by the parser.

ParserGeneratedFlags = StrictMode | DisallowIn | Yield | GeneratorParameter | Decorator | ThisNodeHasError,

// Context flags computed by aggregating child flags upwards.

// Used during incremental parsing to determine if this node or any of its children had an

// error. Computed only once and then cached.

ThisNodeOrAnySubNodesHasError = 1 << 6,

// Used to know if we've computed data from children and cached it in this node.

HasAggregatedChildData = 1 << 7

}

/* @internal */

export const enum RelationComparisonResult {

Succeeded = 1, // Should be truthy

Failed = 2,

FailedAndReported = 3

}

export interface Node extends TextRange {

kind: SyntaxKind;

flags: NodeFlags;

// Specific context the parser was in when this node was created. Normally undefined.

// Only set when the parser was in some interesting context (like async/yield).

/* @internal */ parserContextFlags?: ParserContextFlags;

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

}

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

hasTrailingComma?: boolean;

}

export interface ModifiersArray extends NodeArray<Node> {

flags: number;

}

export interface Identifier extends PrimaryExpression {

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

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

}

export interface QualifiedName extends Node {

// Must have same layout as PropertyAccess

left: EntityName;

right: Identifier;

}

export type EntityName = Identifier | QualifiedName;

export type DeclarationName = Identifier | LiteralExpression | ComputedPropertyName | BindingPattern;

export interface Declaration extends Node {

_declarationBrand: any;

name?: DeclarationName;

}

export interface ComputedPropertyName extends Node {

expression: Expression;

}

export interface Decorator extends Node {

expression: LeftHandSideExpression;

}

export interface TypeParameterDeclaration extends Declaration {

name: Identifier;

constraint?: TypeNode;

// For error recovery purposes.

expression?: Expression;

}

export interface SignatureDeclaration extends Declaration {

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

}

// SyntaxKind.VariableDeclaration

export interface VariableDeclaration extends Declaration {

parent?: VariableDeclarationList;

name: Identifier | BindingPattern; // Declared variable name

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface VariableDeclarationList extends Node {

declarations: NodeArray<VariableDeclaration>;

}

// SyntaxKind.Parameter

export interface ParameterDeclaration extends Declaration {

dotDotDotToken?: Node; // Present on rest parameter

name: Identifier | BindingPattern; // Declared parameter name

questionToken?: Node; // Present on optional parameter

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

// SyntaxKind.BindingElement

export interface BindingElement extends Declaration {

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

dotDotDotToken?: Node; // Present on rest binding element

name: Identifier | BindingPattern; // Declared binding element name

initializer?: Expression; // Optional initializer

}

// SyntaxKind.Property

export interface PropertyDeclaration extends Declaration, ClassElement {

name: DeclarationName; // Declared property name

questionToken?: Node; // Present on optional property

type?: TypeNode; // Optional type annotation

initializer?: Expression; // Optional initializer

}

export interface ObjectLiteralElement extends Declaration {

_objectLiteralBrandBrand: any;

}

// SyntaxKind.PropertyAssignment

export interface PropertyAssignment extends ObjectLiteralElement {

_propertyAssignmentBrand: any;

name: DeclarationName;

questionToken?: Node;

initializer: Expression;

}

// SyntaxKind.ShorthandPropertyAssignment

export interface ShorthandPropertyAssignment extends ObjectLiteralElement {

name: Identifier;

questionToken?: Node;

}

// SyntaxKind.VariableDeclaration

// SyntaxKind.Parameter

// SyntaxKind.BindingElement

// SyntaxKind.Property

// SyntaxKind.PropertyAssignment

// SyntaxKind.ShorthandPropertyAssignment

// SyntaxKind.EnumMember

export interface VariableLikeDeclaration extends Declaration {

propertyName?: Identifier;

dotDotDotToken?: Node;

name: DeclarationName;

questionToken?: Node;

type?: TypeNode;

initializer?: Expression;

}

export interface BindingPattern extends Node {

elements: NodeArray<BindingElement>;

}

/**

export interface FunctionLikeDeclaration extends SignatureDeclaration {

_functionLikeDeclarationBrand: any;

asteriskToken?: Node;

questionToken?: Node;

body?: Block | Expression;

}

export interface FunctionDeclaration extends FunctionLikeDeclaration, Statement {

name?: Identifier;

body?: Block;

}

// 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 FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

body?: Block;

}

export interface ConstructorDeclaration extends FunctionLikeDeclaration, ClassElement {

body?: Block;

}

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

export interface SemicolonClassElement extends ClassElement {

_semicolonClassElementBrand: any;

}

// See the comment on MethodDeclaration for the intuition behind AccessorDeclaration being a

// ClassElement and an ObjectLiteralElement.

export interface AccessorDeclaration extends FunctionLikeDeclaration, ClassElement, ObjectLiteralElement {

_accessorDeclarationBrand: any;

body: Block;

}

export interface IndexSignatureDeclaration extends SignatureDeclaration, ClassElement {

_indexSignatureDeclarationBrand: any;

}

export interface TypeNode extends Node {

_typeNodeBrand: any;

}

export interface FunctionOrConstructorTypeNode extends TypeNode, SignatureDeclaration {

_functionOrConstructorTypeNodeBrand: any;

}

export interface TypeReferenceNode extends TypeNode {

typeName: EntityName;

typeArguments?: NodeArray<TypeNode>;

}

export interface TypeQueryNode extends TypeNode {

exprName: EntityName;

}

// A TypeLiteral is the declaration node for an anonymous symbol.

export interface TypeLiteralNode extends TypeNode, Declaration {

members: NodeArray<Node>;

}

export interface ArrayTypeNode extends TypeNode {

elementType: TypeNode;

}

export interface TupleTypeNode extends TypeNode {

elementTypes: NodeArray<TypeNode>;

}

export interface UnionTypeNode extends TypeNode {

types: NodeArray<TypeNode>;

}

export interface ParenthesizedTypeNode extends TypeNode {

type: TypeNode;

}

// Note that a StringLiteral AST node is both an Expression and a TypeNode. The latter is

// because string literals can appear in the type annotation of a parameter node.

export interface StringLiteral extends LiteralExpression, TypeNode {

_stringLiteralBrand: any;

}

// Note: 'brands' in our syntax nodes serve to give us a small amount of nominal typing.

// Consider 'Expression'. Without the brand, 'Expression' is actually no different

// (structurally) than 'Node'. Because of this you can pass any Node to a function that

// takes an Expression without any error. By using the 'brands' we ensure that the type

// checker actually thinks you have something of the right type. Note: the brands are

// never actually given values. At runtime they have zero cost.

export interface Expression extends Node {

_expressionBrand: any;

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

}

export interface UnaryExpression extends Expression {

_unaryExpressionBrand: any;

}

export interface PrefixUnaryExpression extends UnaryExpression {

operator: SyntaxKind;

operand: UnaryExpression;

}

export interface PostfixUnaryExpression extends PostfixExpression {

operand: LeftHandSideExpression;

operator: SyntaxKind;

}

export interface PostfixExpression extends UnaryExpression {

_postfixExpressionBrand: any;

}

export interface LeftHandSideExpression extends PostfixExpression {

_leftHandSideExpressionBrand: any;

}

export interface MemberExpression extends LeftHandSideExpression {

_memberExpressionBrand: any;

}

export interface PrimaryExpression extends MemberExpression {

_primaryExpressionBrand: any;

}

export interface DeleteExpression extends UnaryExpression {

expression: UnaryExpression;

}

export interface TypeOfExpression extends UnaryExpression {

expression: UnaryExpression;

}

export interface VoidExpression extends UnaryExpression {

expression: UnaryExpression;

}

export interface YieldExpression extends Expression {

asteriskToken?: Node;

expression: Expression;

}

export interface BinaryExpression extends Expression {

left: Expression;

operatorToken: Node;

right: Expression;

}

export interface ConditionalExpression extends Expression {

condition: Expression;

questionToken: Node;

whenTrue: Expression;

colonToken: Node;

whenFalse: Expression;

}

export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclaration {

name?: Identifier;

body: Block | Expression; // Required, whereas the member inherited from FunctionDeclaration is optional

}

export interface ArrowFunction extends Expression, FunctionLikeDeclaration {

equalsGreaterThanToken: Node;

}

// The text property of a LiteralExpression stores the interpreted value of the literal in text form. For a StringLiteral,

// or any literal of a template, this means quotes have been removed and escapes have been converted to actual characters.

// For a NumericLiteral, the stored value is the toString() representation of the number. For example 1, 1.00, and 1e0 are all stored as just "1".

export interface LiteralExpression extends PrimaryExpression {

text: string;

isUnterminated?: boolean;

hasExtendedUnicodeEscape?: boolean;

}

export interface TemplateExpression extends PrimaryExpression {

head: LiteralExpression;

templateSpans: NodeArray<TemplateSpan>;

}

// Each of these corresponds to a substitution expression and a template literal, in that order.

// The template literal must have kind TemplateMiddleLiteral or TemplateTailLiteral.

export interface TemplateSpan extends Node {

expression: Expression;

literal: LiteralExpression;

}

export interface ParenthesizedExpression extends PrimaryExpression {

expression: Expression;

}

export interface ArrayLiteralExpression extends PrimaryExpression {

elements: NodeArray<Expression>;

}

export interface SpreadElementExpression extends Expression {

expression: Expression;

}

// An ObjectLiteralExpression is the declaration node for an anonymous symbol.

export interface ObjectLiteralExpression extends PrimaryExpression, Declaration {

properties: NodeArray<ObjectLiteralElement>;

}

export interface PropertyAccessExpression extends MemberExpression {

expression: LeftHandSideExpression;

dotToken: Node;

name: Identifier;

}

export interface ElementAccessExpression extends MemberExpression {

expression: LeftHandSideExpression;

argumentExpression?: Expression;

}

export interface CallExpression extends LeftHandSideExpression {

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

}

export interface HeritageClauseElement extends TypeNode {

expression: LeftHandSideExpression;

typeArguments?: NodeArray<TypeNode>;

}

export interface NewExpression extends CallExpression, PrimaryExpression { }

export interface TaggedTemplateExpression extends MemberExpression {

tag: LeftHandSideExpression;

template: LiteralExpression | TemplateExpression;

}

export type CallLikeExpression = CallExpression | NewExpression | TaggedTemplateExpression;

export interface TypeAssertion extends UnaryExpression {

type: TypeNode;

expression: UnaryExpression;

}

export interface Statement extends Node, ModuleElement {

_statementBrand: any;

}

export interface Block extends Statement {

statements: NodeArray<Statement>;

}

export interface VariableStatement extends Statement {

declarationList: VariableDeclarationList;

}

export interface ExpressionStatement extends Statement {

expression: Expression;

}

export interface IfStatement extends Statement {

expression: Expression;

thenStatement: Statement;

elseStatement?: Statement;

}

export interface IterationStatement extends Statement {

statement: Statement;

}

export interface DoStatement extends IterationStatement {

expression: Expression;

}

export interface WhileStatement extends IterationStatement {

expression: Expression;

}

export interface ForStatement extends IterationStatement {

initializer?: VariableDeclarationList | Expression;

condition?: Expression;

iterator?: Expression;

}

export interface ForInStatement extends IterationStatement {

initializer: VariableDeclarationList | Expression;

expression: Expression;

}

export interface ForOfStatement extends IterationStatement {

initializer: VariableDeclarationList | Expression;

expression: Expression;

}

export interface BreakOrContinueStatement extends Statement {

label?: Identifier;

}

export interface ReturnStatement extends Statement {

expression?: Expression;

}

export interface WithStatement extends Statement {

expression: Expression;

statement: Statement;

}

export interface SwitchStatement extends Statement {

expression: Expression;

caseBlock: CaseBlock;

}

export interface CaseBlock extends Node {

clauses: NodeArray<CaseOrDefaultClause>;

}

export interface CaseClause extends Node {

expression?: Expression;

statements: NodeArray<Statement>;

}

export interface DefaultClause extends Node {

statements: NodeArray<Statement>;

}

export type CaseOrDefaultClause = CaseClause | DefaultClause;

export interface LabeledStatement extends Statement {

label: Identifier;

statement: Statement;

}

export interface ThrowStatement extends Statement {

expression: Expression;

}

export interface TryStatement extends Statement {

tryBlock: Block;

catchClause?: CatchClause;

finallyBlock?: Block;

}

export interface CatchClause extends Node {

variableDeclaration: VariableDeclaration;

block: Block;

}

export interface ModuleElement extends Node {

_moduleElementBrand: any;

}

export interface ClassLikeDeclaration extends Declaration {

name?: Identifier;

typeParameters?: NodeArray<TypeParameterDeclaration>;

heritageClauses?: NodeArray<HeritageClause>;

members: NodeArray<ClassElement>;

}

export interface ClassDeclaration extends ClassLikeDeclaration, Statement {

}

export interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {

}

export interface ClassElement extends Declaration {

_classElementBrand: any;

}

export interface InterfaceDeclaration extends Declaration, ModuleElement {

name: Identifier;

typeParameters?: NodeArray<TypeParameterDeclaration>;

heritageClauses?: NodeArray<HeritageClause>;

members: NodeArray<Declaration>;

}

export interface HeritageClause extends Node {

token: SyntaxKind;

types?: NodeArray<HeritageClauseElement>;

}

export interface TypeAliasDeclaration extends Declaration, ModuleElement {

name: Identifier;

type: TypeNode;

}

export interface EnumMember extends Declaration {

// This does include ComputedPropertyName, but the parser will give an error

// if it parses a ComputedPropertyName in an EnumMember

name: DeclarationName;

initializer?: Expression;

}

export interface EnumDeclaration extends Declaration, ModuleElement {

name: Identifier;

members: NodeArray<EnumMember>;

}

export interface ModuleDeclaration extends Declaration, ModuleElement {

name: Identifier | LiteralExpression;

body: ModuleBlock | ModuleDeclaration;

}

export interface ModuleBlock extends Node, ModuleElement {

statements: NodeArray<ModuleElement>

}

export interface ImportEqualsDeclaration extends Declaration, ModuleElement {

name: Identifier;

// 'EntityName' for an internal module reference, 'ExternalModuleReference' for an external

// module reference.

moduleReference: EntityName | ExternalModuleReference;

}

export interface ExternalModuleReference extends Node {

expression?: Expression;

}

// In case of:

// import "mod" => importClause = undefined, moduleSpecifier = "mod"

// In rest of the cases, module specifier is string literal corresponding to module

// ImportClause information is shown at its declaration below.

export interface ImportDeclaration extends ModuleElement {

importClause?: ImportClause;

moduleSpecifier: Expression;

}

// In case of:

// import d from "mod" => name = d, namedBinding = undefined

// import * as ns from "mod" => name = undefined, namedBinding: NamespaceImport = { name: ns }

// import d, * as ns from "mod" => name = d, namedBinding: NamespaceImport = { name: ns }

// import { a, b as x } from "mod" => name = undefined, namedBinding: NamedImports = { elements: [{ name: a }, { name: x, propertyName: b}]}

// import d, { a, b as x } from "mod" => name = d, namedBinding: NamedImports = { elements: [{ name: a }, { name: x, propertyName: b}]}

export interface ImportClause extends Declaration {

name?: Identifier; // Default binding

namedBindings?: NamespaceImport | NamedImports;

}

export interface NamespaceImport extends Declaration {

name: Identifier;

}

export interface ExportDeclaration extends Declaration, ModuleElement {

exportClause?: NamedExports;

moduleSpecifier?: Expression;

}

export interface NamedImportsOrExports extends Node {

elements: NodeArray<ImportOrExportSpecifier>;

}

export type NamedImports = NamedImportsOrExports;

export type NamedExports = NamedImportsOrExports;

export interface ImportOrExportSpecifier extends Declaration {

propertyName?: Identifier; // Name preceding "as" keyword (or undefined when "as" is absent)

name: Identifier; // Declared name

}

export type ImportSpecifier = ImportOrExportSpecifier;

export type ExportSpecifier = ImportOrExportSpecifier;

export interface ExportAssignment extends Declaration, ModuleElement {

isExportEquals?: boolean;

expression: Expression;

}

export interface FileReference extends TextRange {

fileName: string;

}

export interface CommentRange extends TextRange {

hasTrailingNewLine?: boolean;

kind: SyntaxKind;

}

// Source files are declarations when they are external modules.

export interface SourceFile extends Declaration {

statements: NodeArray<ModuleElement>;

endOfFileToken: Node;

fileName: string;

text: string;