export interface TextRange {

pos: number;

end: number;

}

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

export enum SyntaxKind {

Unknown,

EndOfFileToken,

// Literals

NumericLiteral,

StringLiteral,

RegularExpressionLiteral,

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

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

// TypeScript keywords

AnyKeyword,

BooleanKeyword,

ConstructorKeyword,

DeclareKeyword,

GetKeyword,

ModuleKeyword,

RequireKeyword,

NumberKeyword,

SetKeyword,

StringKeyword,

// Parse tree nodes

Missing,

// Names

QualifiedName,

// Signature elements

TypeParameter,

Parameter,

// TypeMember

Property,

Method,

Constructor,

GetAccessor,

SetAccessor,

CallSignature,

ConstructSignature,

IndexSignature,

// Type

TypeReference,

TypeQuery,

TypeLiteral,

ArrayType,

// Expression

ArrayLiteral,

ObjectLiteral,

PropertyAssignment,

PropertyAccess,

IndexedAccess,

CallExpression,

NewExpression,

TypeAssertion,

ParenExpression,

FunctionExpression,

ArrowFunction,

PrefixOperator,

PostfixOperator,

BinaryExpression,

ConditionalExpression,

OmittedExpression,

// Element

Block,

VariableStatement,

EmptyStatement,

ExpressionStatement,

IfStatement,

DoStatement,

WhileStatement,

ForStatement,

ForInStatement,

ContinueStatement,

BreakStatement,

ReturnStatement,

WithStatement,

SwitchStatement,

CaseClause,

DefaultClause,

LabelledStatement,

ThrowStatement,

TryStatement,

TryBlock,

CatchBlock,

FinallyBlock,

DebuggerStatement,

VariableDeclaration,

FunctionDeclaration,

FunctionBlock,

ClassDeclaration,

InterfaceDeclaration,

EnumDeclaration,

ModuleDeclaration,

ModuleBlock,

ImportDeclaration,

ExportAssignment,

// Enum

EnumMember,

// Top-level nodes

SourceFile,

Program,

// Synthesized list

SyntaxList,

// Enum value count

Count,

// Markers

FirstAssignment = EqualsToken,

LastAssignment = CaretEqualsToken,

FirstReservedWord = BreakKeyword,

LastReservedWord = WithKeyword,

FirstKeyword = BreakKeyword,

LastKeyword = StringKeyword,

FirstFutureReservedWord = ImplementsKeyword,

LastFutureReservedWord = YieldKeyword

}

export enum NodeFlags {

Export = 0x00000001, // Declarations

Ambient = 0x00000002, // Declarations

QuestionMark = 0x00000004, // Parameter/Property/Method

Rest = 0x00000008, // Parameter

Public = 0x00000010, // Property/Method

Private = 0x00000020, // Property/Method

Static = 0x00000040, // Property/Method

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

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

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

Modifier = Export | Ambient | Public | Private | Static

}

export interface Node extends TextRange {

kind: SyntaxKind;

flags: NodeFlags;

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

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

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

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

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

}

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

export interface Identifier extends Node {

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

}

export interface QualifiedName extends Node {

// Must have same layout as PropertyAccess

left: EntityName;

right: Identifier;

}

export interface EntityName extends Node {

// Identifier, QualifiedName, or Missing

}

export interface ParsedSignature {

typeParameters?: NodeArray<TypeParameterDeclaration>;

parameters: NodeArray<ParameterDeclaration>;

type?: TypeNode;

}

export interface Declaration extends Node {

name?: Identifier;

}

export interface TypeParameterDeclaration extends Declaration {

constraint?: TypeNode;

}

export interface SignatureDeclaration extends Declaration, ParsedSignature { }

export interface VariableDeclaration extends Declaration {

type?: TypeNode;

initializer?: Expression;

}

export interface PropertyDeclaration extends VariableDeclaration { }

export interface ParameterDeclaration extends VariableDeclaration { }

export interface FunctionDeclaration extends Declaration, ParsedSignature {

body?: Node; // Block or Expression

}

export interface MethodDeclaration extends FunctionDeclaration { }

export interface ConstructorDeclaration extends FunctionDeclaration { }

export interface AccessorDeclaration extends FunctionDeclaration { }

export interface TypeNode extends Node { }

export interface TypeReferenceNode extends TypeNode {

typeName: EntityName;

typeArguments?: NodeArray<TypeNode>;

}

export interface TypeQueryNode extends TypeNode {

exprName: EntityName;

}

export interface TypeLiteralNode extends TypeNode {

members: NodeArray<Node>;

}

export interface ArrayTypeNode extends TypeNode {

elementType: TypeNode;

}

export interface StringLiteralTypeNode extends TypeNode {

text: string;

}

export interface Expression extends Node { }

export interface UnaryExpression extends Expression {

operator: SyntaxKind;

operand: Expression;

}

export interface BinaryExpression extends Expression {

left: Expression;

operator: SyntaxKind;

right: Expression;

}

export interface ConditionalExpression extends Expression {

condition: Expression;

whenTrue: Expression;

whenFalse: Expression;

}

export interface FunctionExpression extends Expression, FunctionDeclaration {

body: Node; // Required, whereas the member inherited from FunctionDeclaration is optional

}

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

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

text: string;

}

export interface ParenExpression extends Expression {

expression: Expression;

}

export interface ArrayLiteral extends Expression {

elements: NodeArray<Expression>;

}

export interface ObjectLiteral extends Expression {

properties: NodeArray<Node>;

}

export interface PropertyAccess extends Expression {

left: Expression;

right: Identifier;

}

export interface IndexedAccess extends Expression {

object: Expression;

index: Expression;

}

export interface CallExpression extends Expression {

func: Expression;

typeArguments?: NodeArray<TypeNode>;

arguments: NodeArray<Expression>;

}

export interface NewExpression extends CallExpression { }

export interface TypeAssertion extends Expression {

type: TypeNode;

operand: Expression;

}

export interface Statement extends Node { }

export interface Block extends Statement {

statements: NodeArray<Statement>;

}

export interface VariableStatement extends Statement {

declarations: NodeArray<VariableDeclaration>;

}

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 {

declarations?: NodeArray<VariableDeclaration>;

initializer?: Expression;

condition?: Expression;

iterator?: Expression;

}

export interface ForInStatement extends IterationStatement {

declaration?: VariableDeclaration;

variable?: 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;

clauses: NodeArray<CaseOrDefaultClause>;

}

export interface CaseOrDefaultClause extends Node {

expression?: Expression;

statements: NodeArray<Statement>;

}

export interface LabelledStatement extends Statement {

label: Identifier;

statement: Statement;

}

export interface ThrowStatement extends Statement {

expression: Expression;

}

export interface TryStatement extends Statement {

tryBlock: Block;

catchBlock?: CatchBlock;

finallyBlock?: Block;

}

export interface CatchBlock extends Block {

variable: Identifier;

}

export interface ClassDeclaration extends Declaration {

typeParameters?: NodeArray<TypeParameterDeclaration>;

baseType?: TypeReferenceNode;

implementedTypes?: NodeArray<TypeReferenceNode>;

members: NodeArray<Node>;

}

export interface InterfaceDeclaration extends Declaration {

typeParameters?: NodeArray<TypeParameterDeclaration>;

baseTypes?: NodeArray<TypeReferenceNode>;

members: NodeArray<Node>;

}

export interface EnumMember extends Declaration {

initializer?: Expression;

}

export interface EnumDeclaration extends Declaration {

members: NodeArray<EnumMember>;

}

export interface ModuleDeclaration extends Declaration {

body: Node; // Block or ModuleDeclaration

}

export interface ImportDeclaration extends Declaration {

entityName?: EntityName;

externalModuleName?: LiteralExpression;

}

export interface ExportAssignment extends Statement {

exportName: Identifier;

}

export interface FileReference extends TextRange {

filename: string;

}

export interface SourceFile extends Block {

filename: string;

text: string;

getLineAndCharacterFromPosition(position: number): { line: number; character: number };

amdDependencies: string[];

referencedFiles: FileReference[];

syntacticErrors: Diagnostic[];

semanticErrors: Diagnostic[];

hasNoDefaultLib: boolean;

externalModuleIndicator: Node; // The first node that causes this file to be an external module

nodeCount: number;

identifierCount: number;

symbolCount: number;

}

export interface Program {

getSourceFile(filename: string): SourceFile;

getSourceFiles(): SourceFile[];

getCompilerOptions(): CompilerOptions;

getCompilerHost(): CompilerHost;

getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

getGlobalDiagnostics(): Diagnostic[];

getTypeChecker(): TypeChecker;

getCommonSourceDirectory(): string;

}

export interface SourceMapSpan {

/** Line number in the js file*/

emittedLine: number;

/** Column number in the js file */

emittedColumn: number;

/** Line number in the ts file */

sourceLine: number;

/** Column number in the ts file */

sourceColumn: number;

/** Optional name (index into names array) associated with this span */

nameIndex?: number;

/** ts file (index into sources array) associated with this span*/

sourceIndex: number;

}

export interface SourceMapData {

/** Where the sourcemap file is written */

sourceMapFilePath: string;

/** source map url written in the js file */

jsSourceMappingURL: string;

/** Source map's file field - js file name*/

sourceMapFile: string;

/** Source map's sourceRoot field - location where the sources will be present if not "" */

sourceMapSourceRoot: string;

/** Source map's sources field - list of sources that can be indexed in this source map*/

sourceMapSources: string[];

/** input source file (which one can use on program to get the file)

this is one to one mapping with the sourceMapSources list*/

inputSourceFileNames: string[];

/** Source map's names field - list of names that can be indexed in this source map*/

sourceMapNames?: string[];

/** Source map's mapping field - encoded source map spans*/

sourceMapMappings: string;

/** Raw source map spans that were encoded into the sourceMapMappings*/

sourceMapDecodedMappings: SourceMapSpan[];

}

export interface EmitResult {

errors: Diagnostic[];

sourceMaps: SourceMapData[]; // Array of sourceMapData if compiler emitted sourcemaps

}

export interface TypeChecker {

getProgram(): Program;

getDiagnostics(sourceFile?: SourceFile): Diagnostic[];

getGlobalDiagnostics(): Diagnostic[];

getNodeCount(): number;

getIdentifierCount(): number;

getSymbolCount(): number;

getTypeCount(): number;

checkProgram(): void;

emitFiles(): EmitResult;

getSymbolOfNode(node: Node): Symbol;

getParentOfSymbol(symbol: Symbol): Symbol;

getTypeOfSymbol(symbol: Symbol): Type;

getDeclaredTypeOfSymbol(symbol: Symbol): Type;

getPropertiesOfType(type: Type): Symbol[];

getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];

getIndexTypeOfType(type: Type, kind: IndexKind): Type;

getReturnTypeOfSignature(signature: Signature): Type;

resolveEntityName(location: Node, name: EntityName, meaning: SymbolFlags): Symbol;

getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];

getSymbolOfIdentifier(identifier: Identifier): Symbol;

}

export interface TextWriter {

write(s: string): void;

writeLine(): void;

increaseIndent(): void;

decreaseIndent(): void;

getText(): string;

}

export enum TypeFormatFlags {

None = 0x00000000,

/** writes Array<T> instead T[] */

WriteArrayAsGenericType = 0x00000001, // Declarations

}

export interface EmitResolver {

getProgram(): Program;

getLocalNameOfContainer(container: Declaration): string;

getExpressionNamePrefix(node: Identifier): string;

getPropertyAccessSubstitution(node: PropertyAccess): string;

getExportAssignmentName(node: SourceFile): string;

isReferencedImportDeclaration(node: ImportDeclaration): boolean;

isTopLevelValueImportedViaEntityName(node: ImportDeclaration): boolean;

getNodeCheckFlags(node: Node): NodeCheckFlags;

getEnumMemberValue(node: EnumMember): number;

shouldEmitDeclarations(): boolean;

isDeclarationVisible(node: Declaration): boolean;

isImplementationOfOverload(node: FunctionDeclaration): boolean;

writeTypeAtLocation(location: Node, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;

writeReturnTypeOfSignatureDeclaration(signatureDeclaration: SignatureDeclaration, enclosingDeclaration: Node, flags: TypeFormatFlags, writer: TextWriter): void;

}

export enum SymbolFlags {

Variable = 0x00000001, // Variable or parameter

Property = 0x00000002, // Property or enum member

EnumMember = 0x00000004, // Enum member

Function = 0x00000008, // Function

Class = 0x00000010, // Class

Interface = 0x00000020, // Interface

Enum = 0x00000040, // Enum

ValueModule = 0x00000080, // Instantiated module

NamespaceModule = 0x00000100, // Uninstantiated module

TypeLiteral = 0x00000200, // Type Literal

ObjectLiteral = 0x00000400, // Object Literal

Method = 0x00000800, // Method

Constructor = 0x00001000, // Constructor

GetAccessor = 0x00002000, // Get accessor

SetAccessor = 0x00004000, // Set accessor

CallSignature = 0x00008000, // Call signature

ConstructSignature = 0x00010000, // Construct signature

IndexSignature = 0x00020000, // Index signature

TypeParameter = 0x00040000, // Type parameter

// Export markers (see comment in declareModuleMember in binder)

ExportValue = 0x00080000, // Exported value marker

ExportType = 0x00100000, // Exported type marker

ExportNamespace = 0x00200000, // Exported namespace marker

Import = 0x00400000, // Import

Instantiated = 0x00800000, // Instantiated symbol

Merged = 0x01000000, // Merged symbol (created during program binding)

Transient = 0x02000000, // Transient symbol (created during type check)

Prototype = 0x04000000, // Symbol for the prototype property (without source code representation)

Value = Variable | Property | EnumMember | Function | Class | Enum | ValueModule | Method | GetAccessor | SetAccessor,

Type = Class | Interface | Enum | TypeLiteral | ObjectLiteral | TypeParameter,

Namespace = ValueModule | NamespaceModule,

Module = ValueModule | NamespaceModule,

Accessor = GetAccessor | SetAccessor,

Signature = CallSignature | ConstructSignature | IndexSignature,

ParameterExcludes = Value,

VariableExcludes = Value & ~Variable,

PropertyExcludes = Value,

EnumMemberExcludes = Value,

FunctionExcludes = Value & ~(Function | ValueModule),

ClassExcludes = (Value | Type) & ~ValueModule,

InterfaceExcludes = Type & ~Interface,

EnumExcludes = (Value | Type) & ~(Enum | ValueModule),

ValueModuleExcludes = Value & ~(Function | Class | Enum | ValueModule),

NamespaceModuleExcludes = 0,

MethodExcludes = Value & ~Method,

GetAccessorExcludes = Value & ~SetAccessor,

SetAccessorExcludes = Value & ~GetAccessor,

TypeParameterExcludes = Type & ~TypeParameter,

// Imports collide with all other imports with the same name.

ImportExcludes = Import,

ModuleMember = Variable | Function | Class | Interface | Enum | Module | Import,

ExportHasLocal = Function | Class | Enum | ValueModule,

HasLocals = Function | Module | Method | Constructor | Accessor | Signature,

HasExports = Class | Enum | Module,

HasMembers = Class | Interface | TypeLiteral | ObjectLiteral,

IsContainer = HasLocals | HasExports | HasMembers,

PropertyOrAccessor = Property | Accessor,

}

export interface Symbol {

flags: SymbolFlags; // Symbol flags

name: string; // Name of symbol

id?: number; // Unique id (used to look up SymbolLinks)

mergeId?: number; // Merge id (used to look up merged symbol)

declarations?: Declaration[]; // Declarations associated with this symbol

parent?: Symbol; // Parent symbol

members?: SymbolTable; // Class, interface or literal instance members

exports?: SymbolTable; // Module exports

exportSymbol?: Symbol; // Exported symbol associated with this symbol

exportAssignSymbol?: Symbol; // Symbol exported from external module

valueDeclaration?: Declaration // First value declaration of the symbol

}

export interface SymbolLinks {

target?: Symbol; // Resolved (non-alias) target of an alias

type?: Type; // Type of value symbol

declaredType?: Type; // Type of class, interface, enum, or type parameter

mapper?: TypeMapper; // Type mapper for instantiation alias

referenced?: boolean; // True if alias symbol has been referenced as a value

}

export interface TransientSymbol extends Symbol, SymbolLinks { }

export interface SymbolTable {

[index: string]: Symbol;

}

export enum NodeCheckFlags {

TypeChecked = 0x00000001, // Node has been type checked

LexicalThis = 0x00000002, // Lexical 'this' reference

CaptureThis = 0x00000004, // Lexical 'this' used in body

EmitExtends = 0x00000008, // Emit __extends

SuperInstance = 0x00000010, // Instance 'super' reference

SuperStatic = 0x00000020, // Static 'super' reference

}

export interface NodeLinks {

resolvedType?: Type; // Cached type of type node

resolvedSignature?: Signature; // Cached signature of signature node

resolvedSymbol?: Symbol; // Cached name resolution result

flags?: NodeCheckFlags; // Set of flags specific to Node

enumMemberValue?: number; // Constant value of enum member

isIllegalTypeReferenceInConstraint?: boolean; // Is type reference in constraint refers to the type parameter from the same list

isVisible?: boolean; // Is this node visible

localModuleName?: string; // Local name for module instance

}

export enum TypeFlags {

Any = 0x00000001,

String = 0x00000002,

Number = 0x00000004,

Boolean = 0x00000008,

Void = 0x00000010,

Undefined = 0x00000020,

Null = 0x00000040,

Enum = 0x00000080, // Enum type

StringLiteral = 0x00000100, // String literal type

TypeParameter = 0x00000200, // Type parameter

Class = 0x00000400, // Class

Interface = 0x00000800, // Interface

Reference = 0x00001000, // Generic type reference

Anonymous = 0x00002000, // Anonymous

FromSignature = 0x00004000, // Created for signature assignment check

Intrinsic = Any | String | Number | Boolean | Void | Undefined | Null,

StringLike = String | StringLiteral,

NumberLike = Number | Enum,

ObjectType = Class | Interface | Reference | Anonymous

}

// Properties common to all types

export interface Type {

flags: TypeFlags; // Flags

id: number; // Unique ID

symbol?: Symbol; // Symbol associated with type (if any)

}

// Intrinsic types (TypeFlags.Intrinsic)

export interface IntrinsicType extends Type {

intrinsicName: string; // Name of intrinsic type

}

// String literal types (TypeFlags.StringLiteral)

export interface StringLiteralType extends Type {

text: string; // Text of string literal

}

// Object types (TypeFlags.ObjectType)

export interface ObjectType extends Type { }

export interface ApparentType extends Type {

// This property is not used. It is just to make the type system think ApparentType

// is a strict subtype of Type.

_apparentTypeBrand: any;

}

// Class and interface types (TypeFlags.Class and TypeFlags.Interface)

export interface InterfaceType extends ObjectType {

typeParameters: TypeParameter[]; // Type parameters (undefined if non-generic)

baseTypes: ObjectType[]; // Base types

declaredProperties: Symbol[]; // Declared members

declaredCallSignatures: Signature[]; // Declared call signatures

declaredConstructSignatures: Signature[]; // Declared construct signatures

declaredStringIndexType: Type; // Declared string index type

declaredNumberIndexType: Type; // Declared numeric index type

}

// Type references (TypeFlags.Reference)

export interface TypeReference extends ObjectType {

target: GenericType; // Type reference target

typeArguments: Type[]; // Type reference type arguments

}

// Generic class and interface types

export interface GenericType extends InterfaceType, TypeReference {

instantiations: Map<TypeReference>; // Generic instantiation cache

openReferenceTargets: GenericType[]; // Open type reference targets

openReferenceChecks: Map<boolean>; // Open type reference check cache

}

// Resolved object type

export interface ResolvedObjectType extends ObjectType {

members: SymbolTable; // Properties by name

properties: Symbol[]; // Properties

callSignatures: Signature[]; // Call signatures of type

constructSignatures: Signature[]; // Construct signatures of type

stringIndexType: Type; // String index type

numberIndexType: Type; // Numeric index type

}

// Type parameters (TypeFlags.TypeParameter)

export interface TypeParameter extends Type {

constraint: Type; // Constraint

target?: TypeParameter; // Instantiation target

mapper?: TypeMapper; // Instantiation mapper

}

export enum SignatureKind {

Call,

Construct,

}

export interface Signature {

declaration: SignatureDeclaration; // Originating declaration

typeParameters: TypeParameter[]; // Type parameters (undefined if non-generic)

parameters: Symbol[]; // Parameters

resolvedReturnType: Type; // Resolved return type

minArgumentCount: number; // Number of non-optional parameters

hasRestParameter: boolean; // True if last parameter is rest parameter

hasStringLiterals: boolean; // True if instantiated

target?: Signature; // Instantiation target

mapper?: TypeMapper; // Instantiation mapper

erasedSignatureCache?: Signature; // Erased version of signature (deferred)

isolatedSignatureType?: ObjectType; // A manufactured type that just contains the signature for purposes of signature comparison

}

export enum IndexKind {

String,

Number,

}

export interface TypeMapper {

(t: Type): Type;

}

export interface InferenceContext {

typeParameters: TypeParameter[];

inferences: Type[][];

inferredTypes: Type[];

}

export interface DiagnosticMessage {

key: string;

category: DiagnosticCategory;

code: number;

}

// A linked list of formatted diagnostic messages to be used as part of a multiline message.

// It is built from the bottom up, leaving the head to be the "main" diagnostic.

// While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage,

// the difference is that messages are all preformatted in DMC.

export interface DiagnosticMessageChain {

messageText: string;

category: DiagnosticCategory;

code: number;

next?: DiagnosticMessageChain;

}

export interface Diagnostic {

file: SourceFile;

start: number;

length: number;

messageText: string;

category: DiagnosticCategory;

code: number;

}

export enum DiagnosticCategory {

Warning,

Error,

Message,

NoPrefix

}

export interface CompilerOptions {

charset?: string;

codepage?: number;

declaration?: boolean;

diagnostics?: boolean;

help?: boolean;

locale?: string;

mapRoot?: string;

module?: ModuleKind;

noImplicitAny?: boolean;

noLib?: boolean;

noLibCheck?: boolean;

noResolve?: boolean;

out?: string;

outDir?: string;

removeComments?: boolean;

sourceMap?: boolean;

sourceRoot?: string;

target?: ScriptTarget;

version?: boolean;

[option: string]: any;

}

export enum ModuleKind {

None,

CommonJS,

AMD,

}

export enum ScriptTarget {

ES3,

ES5,

}

export interface ParsedCommandLine {

options: CompilerOptions;

filenames: string[];

errors: Diagnostic[];

}

export interface CommandLineOption {

name: string;

type: any;

error?: DiagnosticMessage;

}

export enum CharacterCodes {

nullCharacter = 0,

maxAsciiCharacter = 0x7F,

lineFeed = 0x0A, // \n

carriageReturn = 0x0D, // \r

lineSeparator = 0x2028,

paragraphSeparator = 0x2029,

// REVIEW: do we need to support this? The scanner doesn't, but our IText does. This seems

// like an odd disparity? (Or maybe it's completely fine for them to be different).

nextLine = 0x0085,

// Unicode 3.0 space characters

space = 0x0020, // " "

nonBreakingSpace = 0x00A0, //

enQuad = 0x2000,

emQuad = 0x2001,

enSpace = 0x2002,

emSpace = 0x2003,

threePerEmSpace = 0x2004,

fourPerEmSpace = 0x2005,

sixPerEmSpace = 0x2006,

figureSpace = 0x2007,

punctuationSpace = 0x2008,

thinSpace = 0x2009,

hairSpace = 0x200A,

zeroWidthSpace = 0x200B,

narrowNoBreakSpace = 0x202F,

ideographicSpace = 0x3000,

mathematicalSpace = 0x205F,

ogham = 0x1680,

_ = 0x5F,

$ = 0x24,

_0 = 0x30,

_1 = 0x31,

_2 = 0x32,

_3 = 0x33,

_4 = 0x34,

_5 = 0x35,

_6 = 0x36,

_7 = 0x37,

_8 = 0x38,