/*! ***************************************************************************** Copyright © 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 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 {

interface MapLike<T> {
    [index: string]: T;
}
interface Map<T> extends MapLike<T> {
    __mapBrand: any;
}
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,
    SetKeyword = 133,
    StringKeyword = 134,
    SymbolKeyword = 135,
    TypeKeyword = 136,
    UndefinedKeyword = 137,
    FromKeyword = 138,
    GlobalKeyword = 139,
    OfKeyword = 140,
    QualifiedName = 141,
    ComputedPropertyName = 142,
    TypeParameter = 143,
    Parameter = 144,
    Decorator = 145,
    PropertySignature = 146,
    PropertyDeclaration = 147,
    MethodSignature = 148,
    MethodDeclaration = 149,
    Constructor = 150,
    GetAccessor = 151,
    SetAccessor = 152,
    CallSignature = 153,
    ConstructSignature = 154,
    IndexSignature = 155,
    TypePredicate = 156,
    TypeReference = 157,
    FunctionType = 158,
    ConstructorType = 159,
    TypeQuery = 160,
    TypeLiteral = 161,
    ArrayType = 162,
    TupleType = 163,
    UnionType = 164,
    IntersectionType = 165,
    ParenthesizedType = 166,
    ThisType = 167,
    TypeOperator = 168,
    IndexedAccessType = 169,
    MappedType = 170,
    LiteralType = 171,
    ObjectBindingPattern = 172,
    ArrayBindingPattern = 173,
    BindingElement = 174,
    ArrayLiteralExpression = 175,
    ObjectLiteralExpression = 176,
    PropertyAccessExpression = 177,
    ElementAccessExpression = 178,
    CallExpression = 179,
    NewExpression = 180,
    TaggedTemplateExpression = 181,
    TypeAssertionExpression = 182,
    ParenthesizedExpression = 183,
    FunctionExpression = 184,
    ArrowFunction = 185,
    DeleteExpression = 186,
    TypeOfExpression = 187,
    VoidExpression = 188,
    AwaitExpression = 189,
    PrefixUnaryExpression = 190,
    PostfixUnaryExpression = 191,
    BinaryExpression = 192,
    ConditionalExpression = 193,
    TemplateExpression = 194,
    YieldExpression = 195,
    SpreadElement = 196,
    ClassExpression = 197,
    OmittedExpression = 198,
    ExpressionWithTypeArguments = 199,
    AsExpression = 200,
    NonNullExpression = 201,
    TemplateSpan = 202,
    SemicolonClassElement = 203,
    Block = 204,
    VariableStatement = 205,
    EmptyStatement = 206,
    ExpressionStatement = 207,
    IfStatement = 208,
    DoStatement = 209,
    WhileStatement = 210,
    ForStatement = 211,
    ForInStatement = 212,
    ForOfStatement = 213,
    ContinueStatement = 214,
    BreakStatement = 215,
    ReturnStatement = 216,
    WithStatement = 217,
    SwitchStatement = 218,
    LabeledStatement = 219,
    ThrowStatement = 220,
    TryStatement = 221,
    DebuggerStatement = 222,
    VariableDeclaration = 223,
    VariableDeclarationList = 224,
    FunctionDeclaration = 225,
    ClassDeclaration = 226,
    InterfaceDeclaration = 227,
    TypeAliasDeclaration = 228,
    EnumDeclaration = 229,
    ModuleDeclaration = 230,
    ModuleBlock = 231,
    CaseBlock = 232,
    NamespaceExportDeclaration = 233,
    ImportEqualsDeclaration = 234,
    ImportDeclaration = 235,
    ImportClause = 236,
    NamespaceImport = 237,
    NamedImports = 238,
    ImportSpecifier = 239,
    ExportAssignment = 240,
    ExportDeclaration = 241,
    NamedExports = 242,
    ExportSpecifier = 243,
    MissingDeclaration = 244,
    ExternalModuleReference = 245,
    JsxElement = 246,
    JsxSelfClosingElement = 247,
    JsxOpeningElement = 248,
    JsxClosingElement = 249,
    JsxAttribute = 250,
    JsxSpreadAttribute = 251,
    JsxExpression = 252,
    CaseClause = 253,
    DefaultClause = 254,
    HeritageClause = 255,
    CatchClause = 256,
    PropertyAssignment = 257,
    ShorthandPropertyAssignment = 258,
    SpreadAssignment = 259,
    EnumMember = 260,
    SourceFile = 261,
    JSDocTypeExpression = 262,
    JSDocAllType = 263,
    JSDocUnknownType = 264,
    JSDocArrayType = 265,
    JSDocUnionType = 266,
    JSDocTupleType = 267,
    JSDocNullableType = 268,
    JSDocNonNullableType = 269,
    JSDocRecordType = 270,
    JSDocRecordMember = 271,
    JSDocTypeReference = 272,
    JSDocOptionalType = 273,
    JSDocFunctionType = 274,
    JSDocVariadicType = 275,
    JSDocConstructorType = 276,
    JSDocThisType = 277,
    JSDocComment = 278,
    JSDocTag = 279,
    JSDocAugmentsTag = 280,
    JSDocParameterTag = 281,
    JSDocReturnTag = 282,
    JSDocTypeTag = 283,
    JSDocTemplateTag = 284,
    JSDocTypedefTag = 285,
    JSDocPropertyTag = 286,
    JSDocTypeLiteral = 287,
    JSDocLiteralType = 288,
    JSDocNullKeyword = 289,
    JSDocUndefinedKeyword = 290,
    JSDocNeverKeyword = 291,
    SyntaxList = 292,
    NotEmittedStatement = 293,
    PartiallyEmittedExpression = 294,
    MergeDeclarationMarker = 295,
    EndOfDeclarationMarker = 296,
    Count = 297,
    FirstAssignment = 57,
    LastAssignment = 69,
    FirstCompoundAssignment = 58,
    LastCompoundAssignment = 69,
    FirstReservedWord = 71,
    LastReservedWord = 106,
    FirstKeyword = 71,
    LastKeyword = 140,
    FirstFutureReservedWord = 107,
    LastFutureReservedWord = 115,
    FirstTypeNode = 156,
    LastTypeNode = 171,
    FirstPunctuation = 16,
    LastPunctuation = 69,
    FirstToken = 0,
    LastToken = 140,
    FirstTriviaToken = 2,
    LastTriviaToken = 7,
    FirstLiteralToken = 8,
    LastLiteralToken = 12,
    FirstTemplateToken = 12,
    LastTemplateToken = 15,
    FirstBinaryOperator = 26,
    LastBinaryOperator = 69,
    FirstNode = 141,
    FirstJSDocNode = 262,
    LastJSDocNode = 288,
    FirstJSDocTagNode = 278,
    LastJSDocTagNode = 291,
}
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;
    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.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 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;
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;
interface NonNullExpression extends LeftHandSideExpression {
    kind: SyntaxKind.NonNullExpression;
    expression: Expression;
}
interface JsxElement extends PrimaryExpression {
    kind: SyntaxKind.JsxElement;
    openingElement: JsxOpeningElement;
    children: NodeArray<JsxChild>;
    closingElement: JsxClosingElement;
}
type JsxTagNameExpression = PrimaryExpression | PropertyAccessExpression;
interface JsxOpeningElement extends Expression {
    kind: SyntaxKind.JsxOpeningElement;
    tagName: JsxTagNameExpression;
    attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;
}
interface JsxSelfClosingElement extends PrimaryExpression {
    kind: SyntaxKind.JsxSelfClosingElement;
    tagName: JsxTagNameExpression;
    attributes: NodeArray<JsxAttribute | JsxSpreadAttribute>;
}
type JsxOpeningLikeElement = JsxSelfClosingElement | JsxOpeningElement;
type JsxAttributeLike = JsxAttribute | JsxSpreadAttribute;
interface JsxAttribute extends Node {
    kind: SyntaxKind.JsxAttribute;
    name: Identifier;
    initializer?: StringLiteral | JsxExpression;
}
interface JsxSpreadAttribute extends Node {
    kind: SyntaxKind.JsxSpreadAttribute;
    expression: Expression;
}
interface JsxClosingElement extends Node {
    kind: SyntaxKind.JsxClosingElement;
    tagName: JsxTagNameExpression;
}
interface JsxExpression extends Expression {
    kind: SyntaxKind.JsxExpression;
    expression?: Expression;
}
interface JsxText extends Node {
    kind: SyntaxKind.JsxText;
}
type JsxChild = JsxText | JsxExpression | JsxElement | JsxSelfClosingElement;
interface Statement extends Node {
    _statementBrand: any;
}
interface EmptyStatement extends Statement {
    kind: SyntaxKind.EmptyStatement;
}
interface DebuggerStatement extends Statement {
    kind: SyntaxKind.DebuggerStatement;
}
interface MissingDeclaration extends DeclarationStatement, ClassElement, ObjectLiteralElement, TypeElement {
    kind: SyntaxKind.MissingDeclaration;
    name?: Identifier;
}
type BlockLike = SourceFile | Block | ModuleBlock | CaseClause;
interface Block extends Statement {
    kind: SyntaxKind.Block;
    statements: NodeArray<Statement>;
}
interface VariableStatement extends Statement {
    kind: SyntaxKind.VariableStatement;
    declarationList: VariableDeclarationList;
}
interface ExpressionStatement extends Statement {
    kind: SyntaxKind.ExpressionStatement;
    expression: Expression;
}
interface IfStatement extends Statement {
    kind: SyntaxKind.IfStatement;
    expression: Expression;
    thenStatement: Statement;
    elseStatement?: Statement;
}
interface IterationStatement extends Statement {
    statement: Statement;
}
interface DoStatement extends IterationStatement {
    kind: SyntaxKind.DoStatement;
    expression: Expression;
}
interface WhileStatement extends IterationStatement {
    kind: SyntaxKind.WhileStatement;
    expression: Expression;
}
type ForInitializer = VariableDeclarationList | Expression;
interface ForStatement extends IterationStatement {
    kind: SyntaxKind.ForStatement;
    initializer?: ForInitializer;
    condition?: Expression;
    incrementor?: Expression;
}
interface ForInStatement extends IterationStatement {
    kind: SyntaxKind.ForInStatement;
    initializer: ForInitializer;
    expression: Expression;
}
interface ForOfStatement extends IterationStatement {
    kind: SyntaxKind.ForOfStatement;
    initializer: ForInitializer;
    expression: Expression;
}
interface BreakStatement extends Statement {
    kind: SyntaxKind.BreakStatement;
    label?: Identifier;
}
interface ContinueStatement extends Statement {
    kind: SyntaxKind.ContinueStatement;
    label?: Identifier;
}
type BreakOrContinueStatement = BreakStatement | ContinueStatement;
interface ReturnStatement extends Statement {
    kind: SyntaxKind.ReturnStatement;
    expression?: Expression;
}
interface WithStatement extends Statement {
    kind: SyntaxKind.WithStatement;
    expression: Expression;
    statement: Statement;
}
interface SwitchStatement extends Statement {
    kind: SyntaxKind.SwitchStatement;
    expression: Expression;
    caseBlock: CaseBlock;
    possiblyExhaustive?: boolean;
}
interface CaseBlock extends Node {
    kind: SyntaxKind.CaseBlock;
    clauses: NodeArray<CaseOrDefaultClause>;
}
interface CaseClause extends Node {
    kind: SyntaxKind.CaseClause;
    expression: Expression;
    statements: NodeArray<Statement>;
}
interface DefaultClause extends Node {
    kind: SyntaxKind.DefaultClause;
    statements: NodeArray<Statement>;
}
type CaseOrDefaultClause = CaseClause | DefaultClause;
interface LabeledStatement extends Statement {
    kind: SyntaxKind.LabeledStatement;
    label: Identifier;
    statement: Statement;
}
interface ThrowStatement extends Statement {
    kind: SyntaxKind.ThrowStatement;
    expression: Expression;
}
interface TryStatement extends Statement {
    kind: SyntaxKind.TryStatement;
    tryBlock: Block;
    catchClause?: CatchClause;
    finallyBlock?: Block;
}
interface CatchClause extends Node {
    kind: SyntaxKind.CatchClause;
    variableDeclaration: VariableDeclaration;
    block: Block;
}
type DeclarationWithTypeParameters = SignatureDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration;
interface ClassLikeDeclaration extends Declaration {
    name?: Identifier;
    typeParameters?: NodeArray<TypeParameterDeclaration>;
    heritageClauses?: NodeArray<HeritageClause>;
    members: NodeArray<ClassElement>;
}
interface ClassDeclaration extends ClassLikeDeclaration, DeclarationStatement {
    kind: SyntaxKind.ClassDeclaration;
    name?: Identifier;
}
interface ClassExpression extends ClassLikeDeclaration, PrimaryExpression {
    kind: SyntaxKind.ClassExpression;
}
interface ClassElement extends Declaration {
    _classElementBrand: any;
    name?: PropertyName;
}
interface TypeElement extends Declaration {
    _typeElementBrand: any;
    name?: PropertyName;
    questionToken?: QuestionToken;
}
interface InterfaceDeclaration extends DeclarationStatement {
    kind: SyntaxKind.InterfaceDeclaration;
    name: Identifier;
    typeParameters?: NodeArray<TypeParameterDeclaration>;
    heritageClauses?: NodeArray<HeritageClause>;
    members: NodeArray<TypeElement>;
}
interface HeritageClause extends Node {
    kind: SyntaxKind.HeritageClause;
    token: SyntaxKind;
    types?: NodeArray<ExpressionWithTypeArguments>;
}
interface TypeAliasDeclaration extends DeclarationStatement {
    kind: SyntaxKind.TypeAliasDeclaration;
    name: Identifier;
    typeParameters?: NodeArray<TypeParameterDeclaration>;
    type: TypeNode;
}
interface EnumMember extends Declaration {
    kind: SyntaxKind.EnumMember;
    name: PropertyName;
    initializer?: Expression;
}
interface EnumDeclaration extends DeclarationStatement {
    kind: SyntaxKind.EnumDeclaration;
    name: Identifier;
    members: NodeArray<EnumMember>;
}
type ModuleBody = ModuleBlock | ModuleDeclaration;
type ModuleName = Identifier | StringLiteral;
interface ModuleDeclaration extends DeclarationStatement {
    kind: SyntaxKind.ModuleDeclaration;
    name: Identifier | StringLiteral;
    body?: ModuleBlock | NamespaceDeclaration | JSDocNamespaceDeclaration | Identifier;
}
interface NamespaceDeclaration extends ModuleDeclaration {
    name: Identifier;
    body: ModuleBlock | NamespaceDeclaration;
}
interface JSDocNamespaceDeclaration extends ModuleDeclaration {
    name: Identifier;
    body: JSDocNamespaceDeclaration | Identifier;
}
interface ModuleBlock extends Node, Statement {
    kind: SyntaxKind.ModuleBlock;
    statements: NodeArray<Statement>;
}
type ModuleReference = EntityName | ExternalModuleReference;
interface ImportEqualsDeclaration extends DeclarationStatement {
    kind: SyntaxKind.ImportEqualsDeclaration;
    name: Identifier;
    moduleReference: ModuleReference;
}
interface ExternalModuleReference extends Node {
    kind: SyntaxKind.ExternalModuleReference;
    expression?: Expression;
}
interface ImportDeclaration extends Statement {
    kind: SyntaxKind.ImportDeclaration;
    importClause?: ImportClause;
    moduleSpecifier: Expression;
}
type NamedImportBindings = NamespaceImport | NamedImports;
interface ImportClause extends Declaration {
    kind: SyntaxKind.ImportClause;
    name?: Identifier;
    namedBindings?: NamedImportBindings;
}
interface NamespaceImport extends Declaration {
    kind: SyntaxKind.NamespaceImport;
    name: Identifier;
}
interface NamespaceExportDeclaration extends DeclarationStatement {
    kind: SyntaxKind.NamespaceExportDeclaration;
    name: Identifier;
    moduleReference: LiteralLikeNode;
}
interface ExportDeclaration extends DeclarationStatement {
    kind: SyntaxKind.ExportDeclaration;
    exportClause?: NamedExports;
    moduleSpecifier?: Expression;
}
interface NamedImports extends Node {
    kind: SyntaxKind.NamedImports;
    elements: NodeArray<ImportSpecifier>;
}
interface NamedExports extends Node {
    kind: SyntaxKind.NamedExports;
    elements: NodeArray<ExportSpecifier>;
}
type NamedImportsOrExports = NamedImports | NamedExports;
interface ImportSpecifier extends Declaration {
    kind: SyntaxKind.ImportSpecifier;
    propertyName?: Identifier;
    name: Identifier;
}
interface ExportSpecifier extends Declaration {
    kind: SyntaxKind.ExportSpecifier;
    propertyName?: Identifier;
    name: Identifier;
}
type ImportOrExportSpecifier = ImportSpecifier | ExportSpecifier;
interface ExportAssignment extends DeclarationStatement {
    kind: SyntaxKind.ExportAssignment;
    isExportEquals?: boolean;
    expression: Expression;
}
interface FileReference extends TextRange {
    fileName: string;
}
interface CommentRange extends TextRange {
    hasTrailingNewLine?: boolean;
    kind: SyntaxKind;
}
interface JSDocTypeExpression extends Node {
    kind: SyntaxKind.JSDocTypeExpression;
    type: JSDocType;
}
interface JSDocType extends TypeNode {
    _jsDocTypeBrand: any;
}
interface JSDocAllType extends JSDocType {
    kind: SyntaxKind.JSDocAllType;
}
interface JSDocUnknownType extends JSDocType {
    kind: SyntaxKind.JSDocUnknownType;
}
interface JSDocArrayType extends JSDocType {
    kind: SyntaxKind.JSDocArrayType;
    elementType: JSDocType;
}
interface JSDocUnionType extends JSDocType {
    kind: SyntaxKind.JSDocUnionType;
    types: NodeArray<JSDocType>;
}
interface JSDocTupleType extends JSDocType {
    kind: SyntaxKind.JSDocTupleType;
    types: NodeArray<JSDocType>;
}
interface JSDocNonNullableType extends JSDocType {
    kind: SyntaxKind.JSDocNonNullableType;
    type: JSDocType;
}
interface JSDocNullableType extends JSDocType {
    kind: SyntaxKind.JSDocNullableType;
    type: JSDocType;
}
interface JSDocRecordType extends JSDocType {
    kind: SyntaxKind.JSDocRecordType;
    literal: TypeLiteralNode;
}
interface JSDocTypeReference extends JSDocType {
    kind: SyntaxKind.JSDocTypeReference;
    name: EntityName;
    typeArguments: NodeArray<JSDocType>;
}
interface JSDocOptionalType extends JSDocType {
    kind: SyntaxKind.JSDocOptionalType;
    type: JSDocType;
}
interface JSDocFunctionType extends JSDocType, SignatureDeclaration {
    kind: SyntaxKind.JSDocFunctionType;
    parameters: NodeArray<ParameterDeclaration>;
    type: JSDocType;
}
interface JSDocVariadicType extends JSDocType {
    kind: SyntaxKind.JSDocVariadicType;
    type: JSDocType;
}
interface JSDocConstructorType extends JSDocType {
    kind: SyntaxKind.JSDocConstructorType;
    type: JSDocType;
}
interface JSDocThisType extends JSDocType {
    kind: SyntaxKind.JSDocThisType;
    type: JSDocType;
}
interface JSDocLiteralType extends JSDocType {
    kind: SyntaxKind.JSDocLiteralType;
    literal: LiteralTypeNode;
}
type JSDocTypeReferencingNode = JSDocThisType | JSDocConstructorType | JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType;
interface JSDocRecordMember extends PropertySignature {
    kind: SyntaxKind.JSDocRecordMember;
    name: Identifier | StringLiteral | NumericLiteral;
    type?: JSDocType;
}
interface JSDoc extends Node {
    kind: SyntaxKind.JSDocComment;
    tags: NodeArray<JSDocTag> | undefined;
    comment: string | undefined;
}
interface JSDocTag extends Node {
    atToken: AtToken;
    tagName: Identifier;
    comment: string | undefined;
}
interface JSDocUnknownTag extends JSDocTag {
    kind: SyntaxKind.JSDocTag;
}
interface JSDocAugmentsTag extends JSDocTag {
    kind: SyntaxKind.JSDocAugmentsTag;
    typeExpression: JSDocTypeExpression;
}
interface JSDocTemplateTag extends JSDocTag {
    kind: SyntaxKind.JSDocTemplateTag;
    typeParameters: NodeArray<TypeParameterDeclaration>;
}
interface JSDocReturnTag extends JSDocTag {
    kind: SyntaxKind.JSDocReturnTag;
    typeExpression: JSDocTypeExpression;
}
interface JSDocTypeTag extends JSDocTag {
    kind: SyntaxKind.JSDocTypeTag;
    typeExpression: JSDocTypeExpression;
}
interface JSDocTypedefTag extends JSDocTag, Declaration {
    kind: SyntaxKind.JSDocTypedefTag;
    fullName?: JSDocNamespaceDeclaration | Identifier;
    name?: Identifier;
    typeExpression?: JSDocTypeExpression;
    jsDocTypeLiteral?: JSDocTypeLiteral;
}
interface JSDocPropertyTag extends JSDocTag, TypeElement {
    kind: SyntaxKind.JSDocPropertyTag;
    name: Identifier;
    typeExpression: JSDocTypeExpression;
}
interface JSDocTypeLiteral extends JSDocType {
    kind: SyntaxKind.JSDocTypeLiteral;
    jsDocPropertyTags?: NodeArray<JSDocPropertyTag>;
    jsDocTypeTag?: JSDocTypeTag;
}
interface JSDocParameterTag extends JSDocTag {
    kind: SyntaxKind.JSDocParameterTag;
    /** the parameter name, if provided *before* the type (TypeScript-style) */
    preParameterName?: Identifier;
    typeExpression?: JSDocTypeExpression;
    /** the parameter name, if provided *after* the type (JSDoc-standard) */
    postParameterName?: Identifier;
    /** the parameter name, regardless of the location it was provided */
    parameterName: Identifier;
    isBracketed: boolean;
}
enum FlowFlags {
    Unreachable = 1,
    Start = 2,
    BranchLabel = 4,
    LoopLabel = 8,
    Assignment = 16,
    TrueCondition = 32,
    FalseCondition = 64,
    SwitchClause = 128,
    ArrayMutation = 256,
    Referenced = 512,
    Shared = 1024,
    Label = 12,
    Condition = 96,
}
interface FlowNode {
    flags: FlowFlags;
    id?: number;
}
interface FlowStart extends FlowNode {
    container?: FunctionExpression | ArrowFunction | MethodDeclaration;
}
interface FlowLabel extends FlowNode {
    antecedents: FlowNode[];
}
interface FlowAssignment extends FlowNode {
    node: Expression | VariableDeclaration | BindingElement;
    antecedent: FlowNode;
}
interface FlowCondition extends FlowNode {
    expression: Expression;
    antecedent: FlowNode;
}
interface FlowSwitchClause extends FlowNode {
    switchStatement: SwitchStatement;
    clauseStart: number;
    clauseEnd: number;
    antecedent: FlowNode;
}
interface FlowArrayMutation extends FlowNode {
    node: CallExpression | BinaryExpression;
    antecedent: FlowNode;
}
type FlowType = Type | IncompleteType;
interface IncompleteType {
    flags: TypeFlags;
    type: Type;
}
interface AmdDependency {
    path: string;
    name: string;
}
interface SourceFile extends Declaration {
    kind: SyntaxKind.SourceFile;
    statements: NodeArray<Statement>;
    endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
    fileName: string;
    path: Path;
    text: string;
    amdDependencies: AmdDependency[];
    moduleName: string;
    referencedFiles: FileReference[];
    typeReferenceDirectives: FileReference[];
    languageVariant: LanguageVariant;
    isDeclarationFile: boolean;
    /**
     * lib.d.ts should have a reference comment like
     *
     *  /// <reference no-default-lib="true"/>
     *
     * If any other file has this comment, it signals not to include lib.d.ts
     * because this containing file is intended to act as a default library.
     */
    hasNoDefaultLib: boolean;
    languageVersion: ScriptTarget;
}
interface ScriptReferenceHost {
    getCompilerOptions(): CompilerOptions;
    getSourceFile(fileName: string): SourceFile;
    getSourceFileByPath(path: Path): SourceFile;
    getCurrentDirectory(): string;
}
interface ParseConfigHost {
    useCaseSensitiveFileNames: boolean;
    readDirectory(rootDir: string, extensions: string[], excludes: string[], includes: string[]): string[];
    /**
      * Gets a value indicating whether the specified path exists and is a file.
      * @param path The path to test.
      */
    fileExists(path: string): boolean;
    readFile(path: string): string;
}
interface WriteFileCallback {
    (fileName: string, data: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: SourceFile[]): void;
}
class OperationCanceledException {
}
interface CancellationToken {
    isCancellationRequested(): boolean;
    /** @throws OperationCanceledException if isCancellationRequested is true */
    throwIfCancellationRequested(): void;
}
interface Program extends ScriptReferenceHost {
    /**
     * Get a list of root file names that were passed to a 'createProgram'
     */
    getRootFileNames(): string[];
    /**
     * Get a list of files in the program
     */
    getSourceFiles(): SourceFile[];
    /**
     * Emits the JavaScript and declaration files.  If targetSourceFile is not specified, then
     * the JavaScript and declaration files will be produced for all the files in this program.
     * If targetSourceFile is specified, then only the JavaScript and declaration for that
     * specific file will be generated.
     *
     * If writeFile is not specified then the writeFile callback from the compiler host will be
     * used for writing the JavaScript and declaration files.  Otherwise, the writeFile parameter
     * will be invoked when writing the JavaScript and declaration files.
     */
    emit(targetSourceFile?: SourceFile, writeFile?: WriteFileCallback, cancellationToken?: CancellationToken, emitOnlyDtsFiles?: boolean): EmitResult;
    getOptionsDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
    getGlobalDiagnostics(cancellationToken?: CancellationToken): Diagnostic[];
    getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
    getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
    getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
    /**
     * Gets a type checker that can be used to semantically analyze source fils in the program.
     */
    getTypeChecker(): TypeChecker;
}
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;
}
interface SourceMapData {
    sourceMapFilePath: string;
    jsSourceMappingURL: string;
    sourceMapFile: string;
    sourceMapSourceRoot: string;
    sourceMapSources: string[];
    sourceMapSourcesContent?: string[];
    inputSourceFileNames: string[];
    sourceMapNames?: string[];
    sourceMapMappings: string;
    sourceMapDecodedMappings: SourceMapSpan[];
}
/** Return code used by getEmitOutput function to indicate status of the function */
enum ExitStatus {
    Success = 0,
    DiagnosticsPresent_OutputsSkipped = 1,
    DiagnosticsPresent_OutputsGenerated = 2,
}
interface EmitResult {
    emitSkipped: boolean;
    /** Contains declaration emit diagnostics */
    diagnostics: Diagnostic[];
    emittedFiles: string[];
}
interface TypeChecker {
    getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type;
    getDeclaredTypeOfSymbol(symbol: Symbol): Type;
    getPropertiesOfType(type: Type): Symbol[];
    getPropertyOfType(type: Type, propertyName: string): Symbol;
    getSignaturesOfType(type: Type, kind: SignatureKind): Signature[];
    getIndexTypeOfType(type: Type, kind: IndexKind): Type;
    getBaseTypes(type: InterfaceType): ObjectType[];
    getReturnTypeOfSignature(signature: Signature): Type;
    getNonNullableType(type: Type): Type;
    getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[];
    getSymbolAtLocation(node: Node): Symbol;
    getSymbolsOfParameterPropertyDeclaration(parameter: ParameterDeclaration, parameterName: string): Symbol[];
    getShorthandAssignmentValueSymbol(location: Node): Symbol;
    getExportSpecifierLocalTargetSymbol(location: ExportSpecifier): Symbol;
    getPropertySymbolOfDestructuringAssignment(location: Identifier): Symbol;
    getTypeAtLocation(node: Node): Type;
    typeToString(type: Type, enclosingDeclaration?: Node, flags?: TypeFormatFlags): string;
    symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): string;
    getSymbolDisplayBuilder(): SymbolDisplayBuilder;
    getFullyQualifiedName(symbol: Symbol): string;
    getAugmentedPropertiesOfType(type: Type): Symbol[];
    getRootSymbols(symbol: Symbol): Symbol[];
    getContextualType(node: Expression): Type;
    getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[]): Signature;
    getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature;
    isImplementationOfOverload(node: FunctionLikeDeclaration): boolean;
    isUndefinedSymbol(symbol: Symbol): boolean;
    isArgumentsSymbol(symbol: Symbol): boolean;
    isUnknownSymbol(symbol: Symbol): boolean;
    getConstantValue(node: EnumMember | PropertyAccessExpression | ElementAccessExpression): number;
    isValidPropertyAccess(node: PropertyAccessExpression | QualifiedName, propertyName: string): boolean;
    getAliasedSymbol(symbol: Symbol): Symbol;
    getExportsOfModule(moduleSymbol: Symbol): Symbol[];
    getJsxElementAttributesType(elementNode: JsxOpeningLikeElement): Type;
    getJsxIntrinsicTagNames(): Symbol[];
    isOptionalParameter(node: ParameterDeclaration): boolean;
    getAmbientModules(): Symbol[];
    tryGetMemberInModuleExports(memberName: string, moduleSymbol: Symbol): Symbol | undefined;
}
interface SymbolDisplayBuilder {
    buildTypeDisplay(type: Type, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildSymbolDisplay(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): void;
    buildSignatureDisplay(signatures: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): void;
    buildParameterDisplay(parameter: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildTypeParameterDisplay(tp: TypeParameter, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildTypePredicateDisplay(predicate: TypePredicate, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildTypeParameterDisplayFromSymbol(symbol: Symbol, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildDisplayForParametersAndDelimiters(thisParameter: Symbol, parameters: Symbol[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildDisplayForTypeParametersAndDelimiters(typeParameters: TypeParameter[], writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
    buildReturnTypeDisplay(signature: Signature, writer: SymbolWriter, enclosingDeclaration?: Node, flags?: TypeFormatFlags): void;
}
interface SymbolWriter {
    writeKeyword(text: string): void;
    writeOperator(text: string): void;
    writePunctuation(text: string): void;
    writeSpace(text: string): void;
    writeStringLiteral(text: string): void;
    writeParameter(text: string): void;
    writeProperty(text: string): void;
    writeSymbol(text: string, symbol: Symbol): void;
    writeLine(): void;
    increaseIndent(): void;
    decreaseIndent(): void;
    clear(): void;
    trackSymbol(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags): void;
    reportInaccessibleThisError(): void;
}
enum TypeFormatFlags {
    None = 0,
    WriteArrayAsGenericType = 1,
    UseTypeOfFunction = 2,
    NoTruncation = 4,
    WriteArrowStyleSignature = 8,
    WriteOwnNameForAnyLike = 16,
    WriteTypeArgumentsOfSignature = 32,
    InElementType = 64,
    UseFullyQualifiedType = 128,
    InFirstTypeArgument = 256,
    InTypeAlias = 512,
    UseTypeAliasValue = 1024,
}
enum SymbolFormatFlags {
    None = 0,
    WriteTypeParametersOrArguments = 1,
    UseOnlyExternalAliasing = 2,
}
enum TypePredicateKind {
    This = 0,
    Identifier = 1,
}
interface TypePredicateBase {
    kind: TypePredicateKind;
    type: Type;
}
interface ThisTypePredicate extends TypePredicateBase {
    kind: TypePredicateKind.This;
}
interface IdentifierTypePredicate extends TypePredicateBase {
    kind: TypePredicateKind.Identifier;
    parameterName: string;
    parameterIndex: number;
}
type TypePredicate = IdentifierTypePredicate | ThisTypePredicate;
enum SymbolFlags {
    None = 0,
    FunctionScopedVariable = 1,
    BlockScopedVariable = 2,
    Property = 4,
    EnumMember = 8,
    Function = 16,
    Class = 32,
    Interface = 64,
    ConstEnum = 128,
    RegularEnum = 256,
    ValueModule = 512,
    NamespaceModule = 1024,
    TypeLiteral = 2048,
    ObjectLiteral = 4096,
    Method = 8192,
    Constructor = 16384,
    GetAccessor = 32768,
    SetAccessor = 65536,
    Signature = 131072,
    TypeParameter = 262144,
    TypeAlias = 524288,
    ExportValue = 1048576,
    ExportType = 2097152,
    ExportNamespace = 4194304,
    Alias = 8388608,
    Instantiated = 16777216,
    Merged = 33554432,
    Transient = 67108864,
    Prototype = 134217728,
    SyntheticProperty = 268435456,
    Optional = 536870912,
    ExportStar = 1073741824,
    Enum = 384,
    Variable = 3,
    Value = 107455,
    Type = 793064,
    Namespace = 1920,
    Module = 1536,
    Accessor = 98304,
    FunctionScopedVariableExcludes = 107454,
    BlockScopedVariableExcludes = 107455,
    ParameterExcludes = 107455,
    PropertyExcludes = 0,
    EnumMemberExcludes = 900095,
    FunctionExcludes = 106927,
    ClassExcludes = 899519,
    InterfaceExcludes = 792968,
    RegularEnumExcludes = 899327,
    ConstEnumExcludes = 899967,
    ValueModuleExcludes = 106639,
    NamespaceModuleExcludes = 0,
    MethodExcludes = 99263,
    GetAccessorExcludes = 41919,
    SetAccessorExcludes = 74687,
    TypeParameterExcludes = 530920,
    TypeAliasExcludes = 793064,
    AliasExcludes = 8388608,
    ModuleMember = 8914931,
    ExportHasLocal = 944,
    HasExports = 1952,
    HasMembers = 6240,
    BlockScoped = 418,
    PropertyOrAccessor = 98308,
    Export = 7340032,
    ClassMember = 106500,
}
interface Symbol {
    flags: SymbolFlags;
    name: string;
    declarations?: Declaration[];
    valueDeclaration?: Declaration;
    members?: SymbolTable;
    exports?: SymbolTable;
    globalExports?: SymbolTable;
}
type SymbolTable = Map<Symbol>;
enum TypeFlags {
    Any = 1,
    String = 2,
    Number = 4,
    Boolean = 8,
    Enum = 16,
    StringLiteral = 32,
    NumberLiteral = 64,
    BooleanLiteral = 128,
    EnumLiteral = 256,
    ESSymbol = 512,
    Void = 1024,
    Undefined = 2048,
    Null = 4096,
    Never = 8192,
    TypeParameter = 16384,
    Object = 32768,
    Union = 65536,
    Intersection = 131072,
    Index = 262144,
    IndexedAccess = 524288,
    Literal = 480,
    StringOrNumberLiteral = 96,
    PossiblyFalsy = 7406,
    StringLike = 262178,
    NumberLike = 340,
    BooleanLike = 136,
    EnumLike = 272,
    UnionOrIntersection = 196608,
    StructuredType = 229376,
    StructuredOrTypeParameter = 507904,
    TypeVariable = 540672,
    Narrowable = 1033215,
    NotUnionOrUnit = 33281,
}
type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression;
interface Type {
    flags: TypeFlags;
    symbol?: Symbol;
    pattern?: DestructuringPattern;
    aliasSymbol?: Symbol;
    aliasTypeArguments?: Type[];
}
interface LiteralType extends Type {
    text: string;
    freshType?: LiteralType;
    regularType?: LiteralType;
}
interface EnumType extends Type {
    memberTypes: Map<EnumLiteralType>;
}
interface EnumLiteralType extends LiteralType {
    baseType: EnumType & UnionType;
}
enum ObjectFlags {
    Class = 1,
    Interface = 2,
    Reference = 4,
    Tuple = 8,
    Anonymous = 16,
    Mapped = 32,
    Instantiated = 64,
    ObjectLiteral = 128,
    EvolvingArray = 256,
    ObjectLiteralPatternWithComputedProperties = 512,
    ClassOrInterface = 3,
}
interface ObjectType extends Type {
    objectFlags: ObjectFlags;
}
interface InterfaceType extends ObjectType {
    typeParameters: TypeParameter[];
    outerTypeParameters: TypeParameter[];
    localTypeParameters: TypeParameter[];
    thisType: TypeParameter;
}
interface InterfaceTypeWithDeclaredMembers extends InterfaceType {
    declaredProperties: Symbol[];
    declaredCallSignatures: Signature[];
    declaredConstructSignatures: Signature[];
    declaredStringIndexInfo: IndexInfo;
    declaredNumberIndexInfo: IndexInfo;
}
interface TypeReference extends ObjectType {
    target: GenericType;
    typeArguments: Type[];
}
interface GenericType extends InterfaceType, TypeReference {
}
interface UnionOrIntersectionType extends Type {
    types: Type[];
}
interface UnionType extends UnionOrIntersectionType {
}
interface IntersectionType extends UnionOrIntersectionType {
}
type StructuredType = ObjectType | UnionType | IntersectionType;
interface EvolvingArrayType extends ObjectType {
    elementType: Type;
    finalArrayType?: Type;
}
interface TypeVariable extends Type {
}
interface TypeParameter extends TypeVariable {
    constraint: Type;
}
interface IndexedAccessType extends TypeVariable {
    objectType: Type;
    indexType: Type;
    constraint?: Type;
}
interface IndexType extends Type {
    type: TypeVariable | UnionOrIntersectionType;
}
enum SignatureKind {
    Call = 0,
    Construct = 1,
}
interface Signature {
    declaration: SignatureDeclaration;
    typeParameters: TypeParameter[];
    parameters: Symbol[];
}
enum IndexKind {
    String = 0,
    Number = 1,
}
interface IndexInfo {
    type: Type;
    isReadonly: boolean;
    declaration?: SignatureDeclaration;
}
interface FileExtensionInfo {
    extension: string;
    scriptKind: ScriptKind;
    isMixedContent: boolean;
}
interface DiagnosticMessage {
    key: string;
    category: DiagnosticCategory;
    code: number;
    message: string;
}
/**
 * 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.
 */
interface DiagnosticMessageChain {
    messageText: string;
    category: DiagnosticCategory;
    code: number;
    next?: DiagnosticMessageChain;
}
interface Diagnostic {
    file: SourceFile;
    start: number;
    length: number;
    messageText: string | DiagnosticMessageChain;
    category: DiagnosticCategory;
    code: number;
}
enum DiagnosticCategory {
    Warning = 0,
    Error = 1,
    Message = 2,
}
enum ModuleResolutionKind {
    Classic = 1,
    NodeJs = 2,
}
type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike<string[]>;
interface CompilerOptions {
    allowJs?: boolean;
    allowSyntheticDefaultImports?: boolean;
    allowUnreachableCode?: boolean;
    allowUnusedLabels?: boolean;
    alwaysStrict?: boolean;
    baseUrl?: string;
    charset?: string;
    declaration?: boolean;
    declarationDir?: string;
    disableSizeLimit?: boolean;
    emitBOM?: boolean;
    emitDecoratorMetadata?: boolean;
    experimentalDecorators?: boolean;
    forceConsistentCasingInFileNames?: boolean;
    importHelpers?: boolean;
    inlineSourceMap?: boolean;
    inlineSources?: boolean;
    isolatedModules?: boolean;
    jsx?: JsxEmit;
    lib?: string[];
    locale?: string;
    mapRoot?: string;
    maxNodeModuleJsDepth?: number;
    module?: ModuleKind;
    moduleResolution?: ModuleResolutionKind;
    newLine?: NewLineKind;
    noEmit?: boolean;
    noEmitHelpers?: boolean;
    noEmitOnError?: boolean;
    noErrorTruncation?: boolean;
    noFallthroughCasesInSwitch?: boolean;
    noImplicitAny?: boolean;
    noImplicitReturns?: boolean;
    noImplicitThis?: boolean;
    noUnusedLocals?: boolean;
    noUnusedParameters?: boolean;
    noImplicitUseStrict?: boolean;
    noLib?: boolean;
    noResolve?: boolean;
    out?: string;
    outDir?: string;
    outFile?: string;
    paths?: MapLike<string[]>;
    preserveConstEnums?: boolean;
    project?: string;
    reactNamespace?: string;
    jsxFactory?: string;
    removeComments?: boolean;
    rootDir?: string;
    rootDirs?: string[];
    skipLibCheck?: boolean;
    skipDefaultLibCheck?: boolean;
    sourceMap?: boolean;
    sourceRoot?: string;
    strictNullChecks?: boolean;
    suppressExcessPropertyErrors?: boolean;
    suppressImplicitAnyIndexErrors?: boolean;
    target?: ScriptTarget;
    traceResolution?: boolean;
    types?: string[];
    /** Paths used to compute primary types search locations */
    typeRoots?: string[];
    [option: string]: CompilerOptionsValue | undefined;
}
interface TypeAcquisition {
    enableAutoDiscovery?: boolean;
    enable?: boolean;
    include?: string[];
    exclude?: string[];
    [option: string]: string[] | boolean | undefined;
}
interface DiscoverTypingsInfo {
    fileNames: string[];
    projectRootPath: string;
    safeListPath: string;
    packageNameToTypingLocation: Map<string>;
    typeAcquisition: TypeAcquisition;
    compilerOptions: CompilerOptions;
    unresolvedImports: ReadonlyArray<string>;
}
enum ModuleKind {
    None = 0,
    CommonJS = 1,
    AMD = 2,
    UMD = 3,
    System = 4,
    ES2015 = 5,
}
enum JsxEmit {
    None = 0,
    Preserve = 1,
    React = 2,
}
enum NewLineKind {
    CarriageReturnLineFeed = 0,
    LineFeed = 1,
}
interface LineAndCharacter {
    line: number;
    character: number;
}
enum ScriptKind {
    Unknown = 0,
    JS = 1,
    JSX = 2,
    TS = 3,
    TSX = 4,
}
enum ScriptTarget {
    ES3 = 0,
    ES5 = 1,
    ES2015 = 2,
    ES2016 = 3,
    ES2017 = 4,
    ESNext = 5,
    Latest = 5,
}
enum LanguageVariant {
    Standard = 0,
    JSX = 1,
}
/** Either a parsed command line or a parsed tsconfig.json */
interface ParsedCommandLine {
    options: CompilerOptions;
    typeAcquisition?: TypeAcquisition;
    fileNames: string[];
    raw?: any;
    errors: Diagnostic[];
    wildcardDirectories?: MapLike<WatchDirectoryFlags>;
    compileOnSave?: boolean;
}
enum WatchDirectoryFlags {
    None = 0,
    Recursive = 1,
}
interface ExpandResult {
    fileNames: string[];
    wildcardDirectories: MapLike<WatchDirectoryFlags>;
}
interface ModuleResolutionHost {
    fileExists(fileName: string): boolean;
    readFile(fileName: string): string;
    trace?(s: string): void;
    directoryExists?(directoryName: string): boolean;
    realpath?(path: string): string;
    getCurrentDirectory?(): string;
    getDirectories?(path: string): string[];
}
/**
 * Represents the result of module resolution.
 * Module resolution will pick up tsx/jsx/js files even if '--jsx' and '--allowJs' are turned off.
 * The Program will then filter results based on these flags.
 *
 * Prefer to return a `ResolvedModuleFull` so that the file type does not have to be inferred.
 */
interface ResolvedModule {
    /** Path of the file the module was resolved to. */
    resolvedFileName: string;
    /**
     * Denotes if 'resolvedFileName' is isExternalLibraryImport and thus should be a proper external module:
     * - be a .d.ts file
     * - use top level imports\exports
     * - don't use tripleslash references
     */
    isExternalLibraryImport?: boolean;
}
/**
 * ResolvedModule with an explicitly provided `extension` property.
 * Prefer this over `ResolvedModule`.
 */
interface ResolvedModuleFull extends ResolvedModule {
    /**
     * Extension of resolvedFileName. This must match what's at the end of resolvedFileName.
     * This is optional for backwards-compatibility, but will be added if not provided.
     */
    extension: Extension;
}
enum Extension {
    Ts = 0,
    Tsx = 1,
    Dts = 2,
    Js = 3,
    Jsx = 4,
    LastTypeScriptExtension = 2,
}
interface ResolvedModuleWithFailedLookupLocations {
    resolvedModule: ResolvedModuleFull | undefined;
    failedLookupLocations: string[];
}
interface ResolvedTypeReferenceDirective {
    primary: boolean;
    resolvedFileName?: string;
}
interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations {
    resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective;
    failedLookupLocations: string[];
}
interface CompilerHost extends ModuleResolutionHost {
    getSourceFile(fileName: string, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
    getSourceFileByPath?(fileName: string, path: Path, languageVersion: ScriptTarget, onError?: (message: string) => void): SourceFile;
    getCancellationToken?(): CancellationToken;
    getDefaultLibFileName(options: CompilerOptions): string;
    getDefaultLibLocation?(): string;
    writeFile: WriteFileCallback;
    getCurrentDirectory(): string;
    getDirectories(path: string): string[];
    getCanonicalFileName(fileName: string): string;
    useCaseSensitiveFileNames(): boolean;
    getNewLine(): string;
    resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
    /**
     * This method is a companion for 'resolveModuleNames' and is used to resolve 'types' references to actual type declaration files
     */
    resolveTypeReferenceDirectives?(typeReferenceDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
    getEnvironmentVariable?(name: string): string;
}
interface TextSpan {
    start: number;
    length: number;
}
interface TextChangeRange {
    span: TextSpan;
    newLength: number;
}
interface SyntaxList extends Node {
    _children: Node[];
}

} declare namespace ts {

/** The version of the TypeScript compiler release */
const version = "2.1.5";

} declare namespace ts {

type FileWatcherCallback = (fileName: string, removed?: boolean) => void;
type DirectoryWatcherCallback = (fileName: string) => void;
interface WatchedFile {
    fileName: string;
    callback: FileWatcherCallback;
    mtime?: Date;
}
interface System {
    args: string[];
    newLine: string;
    useCaseSensitiveFileNames: boolean;
    write(s: string): void;
    readFile(path: string, encoding?: string): string;
    getFileSize?(path: string): number;
    writeFile(path: string, data: string, writeByteOrderMark?: boolean): void;
    /**
     * @pollingInterval - this parameter is used in polling-based watchers and ignored in watchers that
     * use native OS file watching
     */
    watchFile?(path: string, callback: FileWatcherCallback, pollingInterval?: number): FileWatcher;
    watchDirectory?(path: string, callback: DirectoryWatcherCallback, recursive?: boolean): FileWatcher;
    resolvePath(path: string): string;
    fileExists(path: string): boolean;
    directoryExists(path: string): boolean;
    createDirectory(path: string): void;
    getExecutingFilePath(): string;
    getCurrentDirectory(): string;
    getDirectories(path: string): string[];
    readDirectory(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
    getModifiedTime?(path: string): Date;
    createHash?(data: string): string;
    getMemoryUsage?(): number;
    exit(exitCode?: number): void;
    realpath?(path: string): string;
    setTimeout?(callback: (...args: any[]) => void, ms: number, ...args: any[]): any;
    clearTimeout?(timeoutId: any): void;
}
interface FileWatcher {
    close(): void;
}
interface DirectoryWatcher extends FileWatcher {
    directoryName: string;
    referenceCount: number;
}
let sys: System;

} declare namespace ts {

interface ErrorCallback {
    (message: DiagnosticMessage, length: number): void;
}
interface Scanner {
    getStartPos(): number;
    getToken(): SyntaxKind;
    getTextPos(): number;
    getTokenPos(): number;
    getTokenText(): string;
    getTokenValue(): string;
    hasExtendedUnicodeEscape(): boolean;
    hasPrecedingLineBreak(): boolean;
    isIdentifier(): boolean;
    isReservedWord(): boolean;
    isUnterminated(): boolean;
    reScanGreaterToken(): SyntaxKind;
    reScanSlashToken(): SyntaxKind;
    reScanTemplateToken(): SyntaxKind;
    scanJsxIdentifier(): SyntaxKind;
    scanJsxAttributeValue(): SyntaxKind;
    reScanJsxToken(): SyntaxKind;
    scanJsxToken(): SyntaxKind;
    scanJSDocToken(): SyntaxKind;
    scan(): SyntaxKind;
    getText(): string;
    setText(text: string, start?: number, length?: number): void;
    setOnError(onError: ErrorCallback): void;
    setScriptTarget(scriptTarget: ScriptTarget): void;
    setLanguageVariant(variant: LanguageVariant): void;
    setTextPos(textPos: number): void;
    lookAhead<T>(callback: () => T): T;
    scanRange<T>(start: number, length: number, callback: () => T): T;
    tryScan<T>(callback: () => T): T;
}
function tokenToString(t: SyntaxKind): string;
function getPositionOfLineAndCharacter(sourceFile: SourceFile, line: number, character: number): number;
function getLineAndCharacterOfPosition(sourceFile: SourceFile, position: number): LineAndCharacter;
function isWhiteSpace(ch: number): boolean;
/** Does not include line breaks. For that, see isWhiteSpaceLike. */
function isWhiteSpaceSingleLine(ch: number): boolean;
function isLineBreak(ch: number): boolean;
function couldStartTrivia(text: string, pos: number): boolean;
function forEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U;
function forEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T) => U, state?: T): U;
function reduceEachLeadingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U;
function reduceEachTrailingCommentRange<T, U>(text: string, pos: number, cb: (pos: number, end: number, kind: SyntaxKind, hasTrailingNewLine: boolean, state: T, memo: U) => U, state: T, initial: U): U;
function getLeadingCommentRanges(text: string, pos: number): CommentRange[];
function getTrailingCommentRanges(text: string, pos: number): CommentRange[];
/** Optionally, get the shebang */
function getShebang(text: string): string;
function isIdentifierStart(ch: number, languageVersion: ScriptTarget): boolean;
function isIdentifierPart(ch: number, languageVersion: ScriptTarget): boolean;
function createScanner(languageVersion: ScriptTarget, skipTrivia: boolean, languageVariant?: LanguageVariant, text?: string, onError?: ErrorCallback, start?: number, length?: number): Scanner;

} declare namespace ts {

function getDefaultLibFileName(options: CompilerOptions): string;
function textSpanEnd(span: TextSpan): number;
function textSpanIsEmpty(span: TextSpan): boolean;
function textSpanContainsPosition(span: TextSpan, position: number): boolean;
function textSpanContainsTextSpan(span: TextSpan, other: TextSpan): boolean;
function textSpanOverlapsWith(span: TextSpan, other: TextSpan): boolean;
function textSpanOverlap(span1: TextSpan, span2: TextSpan): TextSpan;
function textSpanIntersectsWithTextSpan(span: TextSpan, other: TextSpan): boolean;
function textSpanIntersectsWith(span: TextSpan, start: number, length: number): boolean;
function decodedTextSpanIntersectsWith(start1: number, length1: number, start2: number, length2: number): boolean;
function textSpanIntersectsWithPosition(span: TextSpan, position: number): boolean;
function textSpanIntersection(span1: TextSpan, span2: TextSpan): TextSpan;
function createTextSpan(start: number, length: number): TextSpan;
function createTextSpanFromBounds(start: number, end: number): TextSpan;
function textChangeRangeNewSpan(range: TextChangeRange): TextSpan;
function textChangeRangeIsUnchanged(range: TextChangeRange): boolean;
function createTextChangeRange(span: TextSpan, newLength: number): TextChangeRange;
let unchangedTextChangeRange: TextChangeRange;
/**
 * Called to merge all the changes that occurred across several versions of a script snapshot
 * into a single change.  i.e. if a user keeps making successive edits to a script we will
 * have a text change from V1 to V2, V2 to V3, ..., Vn.
 *
 * This function will then merge those changes into a single change range valid between V1 and
 * Vn.
 */
function collapseTextChangeRangesAcrossMultipleVersions(changes: TextChangeRange[]): TextChangeRange;
function getTypeParameterOwner(d: Declaration): Declaration;
function isParameterPropertyDeclaration(node: Node): boolean;
function getCombinedModifierFlags(node: Node): ModifierFlags;
function getCombinedNodeFlags(node: Node): NodeFlags;
/**
  * Checks to see if the locale is in the appropriate format,
  * and if it is, attempts to set the appropriate language.
  */
function validateLocaleAndSetLanguage(locale: string, sys: {
    getExecutingFilePath(): string;
    resolvePath(path: string): string;
    fileExists(fileName: string): boolean;
    readFile(fileName: string): string;
}, errors?: Diagnostic[]): void;

} declare namespace ts {

function createNode(kind: SyntaxKind, pos?: number, end?: number): Node;
function forEachChild<T>(node: Node, cbNode: (node: Node) => T, cbNodeArray?: (nodes: Node[]) => T): T;
function createSourceFile(fileName: string, sourceText: string, languageVersion: ScriptTarget, setParentNodes?: boolean, scriptKind?: ScriptKind): SourceFile;
function parseIsolatedEntityName(text: string, languageVersion: ScriptTarget): EntityName;
function isExternalModule(file: SourceFile): boolean;
function updateSourceFile(sourceFile: SourceFile, newText: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;

} declare namespace ts {

function moduleHasNonRelativeName(moduleName: string): boolean;
function getEffectiveTypeRoots(options: CompilerOptions, host: {
    directoryExists?: (directoryName: string) => boolean;
    getCurrentDirectory?: () => string;
}): string[] | undefined;
/**
 * @param {string | undefined} containingFile - file that contains type reference directive, can be undefined if containing file is unknown.
 * This is possible in case if resolution is performed for directives specified via 'types' parameter. In this case initial path for secondary lookups
 * is assumed to be the same as root directory of the project.
 */
function resolveTypeReferenceDirective(typeReferenceDirectiveName: string, containingFile: string | undefined, options: CompilerOptions, host: ModuleResolutionHost): ResolvedTypeReferenceDirectiveWithFailedLookupLocations;
/**
  * Given a set of options, returns the set of type directive names
  *   that should be included for this program automatically.
  * This list could either come from the config file,
  *   or from enumerating the types root + initial secondary types lookup location.
  * More type directives might appear in the program later as a result of loading actual source files;
  *   this list is only the set of defaults that are implicitly included.
  */
function getAutomaticTypeDirectiveNames(options: CompilerOptions, host: ModuleResolutionHost): string[];
/**
 * Cached module resolutions per containing directory.
 * This assumes that any module id will have the same resolution for sibling files located in the same folder.
 */
interface ModuleResolutionCache extends NonRelativeModuleNameResolutionCache {
    getOrCreateCacheForDirectory(directoryName: string): Map<ResolvedModuleWithFailedLookupLocations>;
}
/**
 * Stored map from non-relative module name to a table: directory -> result of module lookup in this directory
 * We support only non-relative module names because resolution of relative module names is usually more deterministic and thus less expensive.
 */
interface NonRelativeModuleNameResolutionCache {
    getOrCreateCacheForModuleName(nonRelativeModuleName: string): PerModuleNameCache;
}
interface PerModuleNameCache {
    get(directory: string): ResolvedModuleWithFailedLookupLocations;
    set(directory: string, result: ResolvedModuleWithFailedLookupLocations): void;
}
function createModuleResolutionCache(currentDirectory: string, getCanonicalFileName: (s: string) => string): ModuleResolutionCache;
function resolveModuleName(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations;
function nodeModuleNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: ModuleResolutionCache): ResolvedModuleWithFailedLookupLocations;
function classicNameResolver(moduleName: string, containingFile: string, compilerOptions: CompilerOptions, host: ModuleResolutionHost, cache?: NonRelativeModuleNameResolutionCache): ResolvedModuleWithFailedLookupLocations;

} declare namespace ts {

function findConfigFile(searchPath: string, fileExists: (fileName: string) => boolean, configName?: string): string;
function resolveTripleslashReference(moduleName: string, containingFile: string): string;
function createCompilerHost(options: CompilerOptions, setParentNodes?: boolean): CompilerHost;
function getPreEmitDiagnostics(program: Program, sourceFile?: SourceFile, cancellationToken?: CancellationToken): Diagnostic[];
interface FormatDiagnosticsHost {
    getCurrentDirectory(): string;
    getCanonicalFileName(fileName: string): string;
    getNewLine(): string;
}
function formatDiagnostics(diagnostics: Diagnostic[], host: FormatDiagnosticsHost): string;
function flattenDiagnosticMessageText(messageText: string | DiagnosticMessageChain, newLine: string): string;
function createProgram(rootNames: string[], options: CompilerOptions, host?: CompilerHost, oldProgram?: Program): Program;

} declare namespace ts {

function parseCommandLine(commandLine: string[], readFile?: (path: string) => string): ParsedCommandLine;
/**
  * Read tsconfig.json file
  * @param fileName The path to the config file
  */
function readConfigFile(fileName: string, readFile: (path: string) => string): {
    config?: any;
    error?: Diagnostic;
};
/**
  * Parse the text of the tsconfig.json file
  * @param fileName The path to the config file
  * @param jsonText The text of the config file
  */
function parseConfigFileTextToJson(fileName: string, jsonText: string, stripComments?: boolean): {
    config?: any;
    error?: Diagnostic;
};
/**
  * Parse the contents of a config file (tsconfig.json).
  * @param json The contents of the config file to parse
  * @param host Instance of ParseConfigHost used to enumerate files in folder.
  * @param basePath A root directory to resolve relative path entries in the config
  *    file to. e.g. outDir
  */
function parseJsonConfigFileContent(json: any, host: ParseConfigHost, basePath: string, existingOptions?: CompilerOptions, configFileName?: string, resolutionStack?: Path[], extraFileExtensions?: FileExtensionInfo[]): ParsedCommandLine;
function convertCompileOnSaveOptionFromJson(jsonOption: any, basePath: string, errors: Diagnostic[]): boolean;
function convertCompilerOptionsFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
    options: CompilerOptions;
    errors: Diagnostic[];
};
function convertTypeAcquisitionFromJson(jsonOptions: any, basePath: string, configFileName?: string): {
    options: TypeAcquisition;
    errors: Diagnostic[];
};

} declare namespace ts {

interface Node {
    getSourceFile(): SourceFile;
    getChildCount(sourceFile?: SourceFile): number;
    getChildAt(index: number, sourceFile?: SourceFile): Node;
    getChildren(sourceFile?: SourceFile): Node[];
    getStart(sourceFile?: SourceFile, includeJsDocComment?: boolean): number;
    getFullStart(): number;
    getEnd(): number;
    getWidth(sourceFile?: SourceFile): number;
    getFullWidth(): number;
    getLeadingTriviaWidth(sourceFile?: SourceFile): number;
    getFullText(sourceFile?: SourceFile): string;
    getText(sourceFile?: SourceFile): string;
    getFirstToken(sourceFile?: SourceFile): Node;
    getLastToken(sourceFile?: SourceFile): Node;
}
interface Symbol {
    getFlags(): SymbolFlags;
    getName(): string;
    getDeclarations(): Declaration[];
    getDocumentationComment(): SymbolDisplayPart[];
    getJsDocTags(): JSDocTagInfo[];
}
interface Type {
    getFlags(): TypeFlags;
    getSymbol(): Symbol;
    getProperties(): Symbol[];
    getProperty(propertyName: string): Symbol;
    getApparentProperties(): Symbol[];
    getCallSignatures(): Signature[];
    getConstructSignatures(): Signature[];
    getStringIndexType(): Type;
    getNumberIndexType(): Type;
    getBaseTypes(): ObjectType[];
    getNonNullableType(): Type;
}
interface Signature {
    getDeclaration(): SignatureDeclaration;
    getTypeParameters(): Type[];
    getParameters(): Symbol[];
    getReturnType(): Type;
    getDocumentationComment(): SymbolDisplayPart[];
    getJsDocTags(): JSDocTagInfo[];
}
interface SourceFile {
    getLineAndCharacterOfPosition(pos: number): LineAndCharacter;
    getLineEndOfPosition(pos: number): number;
    getLineStarts(): number[];
    getPositionOfLineAndCharacter(line: number, character: number): number;
    update(newText: string, textChangeRange: TextChangeRange): SourceFile;
}
/**
 * Represents an immutable snapshot of a script at a specified time.Once acquired, the
 * snapshot is observably immutable. i.e. the same calls with the same parameters will return
 * the same values.
 */
interface IScriptSnapshot {
    /** Gets a portion of the script snapshot specified by [start, end). */
    getText(start: number, end: number): string;
    /** Gets the length of this script snapshot. */
    getLength(): number;
    /**
     * Gets the TextChangeRange that describe how the text changed between this text and
     * an older version.  This information is used by the incremental parser to determine
     * what sections of the script need to be re-parsed.  'undefined' can be returned if the
     * change range cannot be determined.  However, in that case, incremental parsing will
     * not happen and the entire document will be re - parsed.
     */
    getChangeRange(oldSnapshot: IScriptSnapshot): TextChangeRange | undefined;
    /** Releases all resources held by this script snapshot */
    dispose?(): void;
}
namespace ScriptSnapshot {
    function fromString(text: string): IScriptSnapshot;
}
interface PreProcessedFileInfo {
    referencedFiles: FileReference[];
    typeReferenceDirectives: FileReference[];
    importedFiles: FileReference[];
    ambientExternalModules: string[];
    isLibFile: boolean;
}
interface HostCancellationToken {
    isCancellationRequested(): boolean;
}
interface LanguageServiceHost {
    getCompilationSettings(): CompilerOptions;
    getNewLine?(): string;
    getProjectVersion?(): string;
    getScriptFileNames(): string[];
    getScriptKind?(fileName: string): ScriptKind;
    getScriptVersion(fileName: string): string;
    getScriptSnapshot(fileName: string): IScriptSnapshot | undefined;
    getLocalizedDiagnosticMessages?(): any;
    getCancellationToken?(): HostCancellationToken;
    getCurrentDirectory(): string;
    getDefaultLibFileName(options: CompilerOptions): string;
    log?(s: string): void;
    trace?(s: string): void;
    error?(s: string): void;
    useCaseSensitiveFileNames?(): boolean;
    readDirectory?(path: string, extensions?: string[], exclude?: string[], include?: string[]): string[];
    readFile?(path: string, encoding?: string): string;
    fileExists?(path: string): boolean;
    getTypeRootsVersion?(): number;
    resolveModuleNames?(moduleNames: string[], containingFile: string): ResolvedModule[];
    resolveTypeReferenceDirectives?(typeDirectiveNames: string[], containingFile: string): ResolvedTypeReferenceDirective[];
    directoryExists?(directoryName: string): boolean;
    getDirectories?(directoryName: string): string[];
}
interface LanguageService {
    cleanupSemanticCache(): void;
    getSyntacticDiagnostics(fileName: string): Diagnostic[];
    getSemanticDiagnostics(fileName: string): Diagnostic[];
    getCompilerOptionsDiagnostics(): Diagnostic[];
    /**
     * @deprecated Use getEncodedSyntacticClassifications instead.
     */
    getSyntacticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
    /**
     * @deprecated Use getEncodedSemanticClassifications instead.
     */
    getSemanticClassifications(fileName: string, span: TextSpan): ClassifiedSpan[];
    getEncodedSyntacticClassifications(fileName: string, span: TextSpan): Classifications;
    getEncodedSemanticClassifications(fileName: string, span: TextSpan): Classifications;
    getCompletionsAtPosition(fileName: string, position: number): CompletionInfo;
    getCompletionEntryDetails(fileName: string, position: number, entryName: string): CompletionEntryDetails;
    getCompletionEntrySymbol(fileName: string, position: number, entryName: string): Symbol;
    getQuickInfoAtPosition(fileName: string, position: number): QuickInfo;
    getNameOrDottedNameSpan(fileName: string, startPos: number, endPos: number): TextSpan;
    getBreakpointStatementAtPosition(fileName: string, position: number): TextSpan;
    getSignatureHelpItems(fileName: string, position: number): SignatureHelpItems;
    getRenameInfo(fileName: string, position: number): RenameInfo;
    findRenameLocations(fileName: string, position: number, findInStrings: boolean, findInComments: boolean): RenameLocation[];
    getDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
    getTypeDefinitionAtPosition(fileName: string, position: number): DefinitionInfo[];
    getImplementationAtPosition(fileName: string, position: number): ImplementationLocation[];
    getReferencesAtPosition(fileName: string, position: number): ReferenceEntry[];
    findReferences(fileName: string, position: number): ReferencedSymbol[];
    getDocumentHighlights(fileName: string, position: number, filesToSearch: string[]): DocumentHighlights[];
    /** @deprecated */
    getOccurrencesAtPosition(fileName: string, position: number): ReferenceEntry[];
    getNavigateToItems(searchValue: string, maxResultCount?: number, fileName?: string, excludeDtsFiles?: boolean): NavigateToItem[];
    getNavigationBarItems(fileName: string): NavigationBarItem[];
    getNavigationTree(fileName: string): NavigationTree;
    getOutliningSpans(fileName: string): OutliningSpan[];
    getTodoComments(fileName: string, descriptors: TodoCommentDescriptor[]): TodoComment[];
    getBraceMatchingAtPosition(fileName: string, position: number): TextSpan[];
    getIndentationAtPosition(fileName: string, position: number, options: EditorOptions | EditorSettings): number;
    getFormattingEditsForRange(fileName: string, start: number, end: number, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
    getFormattingEditsForDocument(fileName: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
    getFormattingEditsAfterKeystroke(fileName: string, position: number, key: string, options: FormatCodeOptions | FormatCodeSettings): TextChange[];
    getDocCommentTemplateAtPosition(fileName: string, position: number): TextInsertion;
    isValidBraceCompletionAtPosition(fileName: string, position: number, openingBrace: number): boolean;
    getCodeFixesAtPosition(fileName: string, start: number, end: number, errorCodes: number[]): CodeAction[];
    getEmitOutput(fileName: string, emitOnlyDtsFiles?: boolean): EmitOutput;
    getProgram(): Program;
    dispose(): void;
}
interface Classifications {
    spans: number[];
    endOfLineState: EndOfLineState;
}
interface ClassifiedSpan {
    textSpan: TextSpan;
    classificationType: string;
}
/**
 * Navigation bar interface designed for visual studio's dual-column layout.
 * This does not form a proper tree.
 * The navbar is returned as a list of top-level items, each of which has a list of child items.
 * Child items always have an empty array for their `childItems`.
 */
interface NavigationBarItem {
    text: string;
    kind: string;
    kindModifiers: string;
    spans: TextSpan[];
    childItems: NavigationBarItem[];
    indent: number;
    bolded: boolean;
    grayed: boolean;
}
/**
 * Node in a tree of nested declarations in a file.
 * The top node is always a script or module node.
 */
interface NavigationTree {
    /** Name of the declaration, or a short description, e.g. "<class>". */
    text: string;
    /** A ScriptElementKind */
    kind: string;
    /** ScriptElementKindModifier separated by commas, e.g. "public,abstract" */
    kindModifiers: string;
    /**
     * Spans of the nodes that generated this declaration.
     * There will be more than one if this is the result of merging.
     */
    spans: TextSpan[];
    /** Present if non-empty */
    childItems?: NavigationTree[];
}
interface TodoCommentDescriptor {
    text: string;
    priority: number;
}
interface TodoComment {
    descriptor: TodoCommentDescriptor;
    message: string;
    position: number;
}
class TextChange {
    span: TextSpan;
    newText: string;
}
interface FileTextChanges {
    fileName: string;
    textChanges: TextChange[];
}
interface CodeAction {
    /** Description of the code action to display in the UI of the editor */
    description: string;
    /** Text changes to apply to each file as part of the code action */
    changes: FileTextChanges[];
}
interface TextInsertion {
    newText: string;
    /** The position in newText the caret should point to after the insertion. */
    caretOffset: number;
}
interface RenameLocation {
    textSpan: TextSpan;
    fileName: string;
}
interface ReferenceEntry {
    textSpan: TextSpan;
    fileName: string;
    isWriteAccess: boolean;
    isDefinition: boolean;
}
interface ImplementationLocation {
    textSpan: TextSpan;
    fileName: string;
}
interface DocumentHighlights {
    fileName: string;
    highlightSpans: HighlightSpan[];
}
namespace HighlightSpanKind {
    const none = "none";
    const definition = "definition";
    const reference = "reference";
    const writtenReference = "writtenReference";
}
interface HighlightSpan {
    fileName?: string;
    textSpan: TextSpan;
    kind: string;
}
interface NavigateToItem {
    name: string;
    kind: string;
    kindModifiers: string;
    matchKind: string;
    isCaseSensitive: boolean;
    fileName: string;
    textSpan: TextSpan;
    containerName: string;
    containerKind: string;
}
enum IndentStyle {
    None = 0,
    Block = 1,
    Smart = 2,
}
interface EditorOptions {
    BaseIndentSize?: number;
    IndentSize: number;
    TabSize: number;
    NewLineCharacter: string;
    ConvertTabsToSpaces: boolean;
    IndentStyle: IndentStyle;
}
interface EditorSettings {
    baseIndentSize?: number;
    indentSize?: number;
    tabSize?: number;
    newLineCharacter?: string;
    convertTabsToSpaces?: boolean;
    indentStyle?: IndentStyle;
}
interface FormatCodeOptions extends EditorOptions {
    InsertSpaceAfterCommaDelimiter: boolean;
    InsertSpaceAfterSemicolonInForStatements: boolean;
    InsertSpaceBeforeAndAfterBinaryOperators: boolean;
    InsertSpaceAfterConstructor?: boolean;
    InsertSpaceAfterKeywordsInControlFlowStatements: boolean;
    InsertSpaceAfterFunctionKeywordForAnonymousFunctions: boolean;
    InsertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis: boolean;
    InsertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets: boolean;
    InsertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
    InsertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces: boolean;
    InsertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
    InsertSpaceAfterTypeAssertion?: boolean;
    InsertSpaceBeforeFunctionParenthesis?: boolean;
    PlaceOpenBraceOnNewLineForFunctions: boolean;
    PlaceOpenBraceOnNewLineForControlBlocks: boolean;
}
interface FormatCodeSettings extends EditorSettings {
    insertSpaceAfterCommaDelimiter?: boolean;
    insertSpaceAfterSemicolonInForStatements?: boolean;
    insertSpaceBeforeAndAfterBinaryOperators?: boolean;
    insertSpaceAfterConstructor?: boolean;
    insertSpaceAfterKeywordsInControlFlowStatements?: boolean;
    insertSpaceAfterFunctionKeywordForAnonymousFunctions?: boolean;
    insertSpaceAfterOpeningAndBeforeClosingNonemptyParenthesis?: boolean;
    insertSpaceAfterOpeningAndBeforeClosingNonemptyBrackets?: boolean;
    insertSpaceAfterOpeningAndBeforeClosingNonemptyBraces?: boolean;
    insertSpaceAfterOpeningAndBeforeClosingTemplateStringBraces?: boolean;
    insertSpaceAfterOpeningAndBeforeClosingJsxExpressionBraces?: boolean;
    insertSpaceAfterTypeAssertion?: boolean;
    insertSpaceBeforeFunctionParenthesis?: boolean;
    placeOpenBraceOnNewLineForFunctions?: boolean;
    placeOpenBraceOnNewLineForControlBlocks?: boolean;
}
interface DefinitionInfo {
    fileName: string;
    textSpan: TextSpan;
    kind: string;
    name: string;
    containerKind: string;
    containerName: string;
}
interface ReferencedSymbolDefinitionInfo extends DefinitionInfo {
    displayParts: SymbolDisplayPart[];
}
interface ReferencedSymbol {
    definition: ReferencedSymbolDefinitionInfo;
    references: ReferenceEntry[];
}
enum SymbolDisplayPartKind {
    aliasName = 0,
    className = 1,
    enumName = 2,
    fieldName = 3,
    interfaceName = 4,
    keyword = 5,
    lineBreak = 6,
    numericLiteral = 7,
    stringLiteral = 8,
    localName = 9,
    methodName = 10,
    moduleName = 11,
    operator = 12,
    parameterName = 13,
    propertyName = 14,
    punctuation = 15,
    space = 16,
    text = 17,
    typeParameterName = 18,
    enumMemberName = 19,
    functionName = 20,
    regularExpressionLiteral = 21,
}
interface SymbolDisplayPart {
    text: string;
    kind: string;
}
interface JSDocTagInfo {
    name: string;
    text?: string;
}
interface QuickInfo {
    kind: string;
    kindModifiers: string;
    textSpan: TextSpan;
    displayParts: SymbolDisplayPart[];
    documentation: SymbolDisplayPart[];
    tags: JSDocTagInfo[];
}
interface RenameInfo {
    canRename: boolean;
    localizedErrorMessage: string;
    displayName: string;
    fullDisplayName: string;
    kind: string;
    kindModifiers: string;
    triggerSpan: TextSpan;
}
interface SignatureHelpParameter {
    name: string;
    documentation: SymbolDisplayPart[];
    displayParts: SymbolDisplayPart[];
    isOptional: boolean;
}
/**
 * Represents a single signature to show in signature help.
 * The id is used for subsequent calls into the language service to ask questions about the
 * signature help item in the context of any documents that have been updated.  i.e. after
 * an edit has happened, while signature help is still active, the host can ask important
 * questions like 'what parameter is the user currently contained within?'.
 */
interface SignatureHelpItem {
    isVariadic: boolean;
    prefixDisplayParts: SymbolDisplayPart[];
    suffixDisplayParts: SymbolDisplayPart[];
    separatorDisplayParts: SymbolDisplayPart[];
    parameters: SignatureHelpParameter[];
    documentation: SymbolDisplayPart[];
    tags: JSDocTagInfo[];
}
/**
 * Represents a set of signature help items, and the preferred item that should be selected.
 */
interface SignatureHelpItems {
    items: SignatureHelpItem[];
    applicableSpan: TextSpan;
    selectedItemIndex: number;
    argumentIndex: number;
    argumentCount: number;
}
interface CompletionInfo {
    isGlobalCompletion: boolean;
    isMemberCompletion: boolean;
    /**
     * true when the current location also allows for a new identifier
     */
    isNewIdentifierLocation: boolean;
    entries: CompletionEntry[];
}
interface CompletionEntry {
    name: string;
    kind: string;
    kindModifiers: string;
    sortText: string;
    /**
      * An optional span that indicates the text to be replaced by this completion item. It will be
      * set if the required span differs from the one generated by the default replacement behavior and should
      * be used in that case
      */
    replacementSpan?: TextSpan;
}
interface CompletionEntryDetails {
    name: string;
    kind: string;
    kindModifiers: string;
    displayParts: SymbolDisplayPart[];
    documentation: SymbolDisplayPart[];
    tags: JSDocTagInfo[];
}
interface OutliningSpan {
    /** The span of the document to actually collapse. */
    textSpan: TextSpan;
    /** The span of the document to display when the user hovers over the collapsed span. */
    hintSpan: TextSpan;
    /** The text to display in the editor for the collapsed region. */
    bannerText: string;
    /**
      * Whether or not this region should be automatically collapsed when
      * the 'Collapse to Definitions' command is invoked.
      */
    autoCollapse: boolean;
}
interface EmitOutput {
    outputFiles: OutputFile[];
    emitSkipped: boolean;
}
enum OutputFileType {
    JavaScript = 0,
    SourceMap = 1,
    Declaration = 2,
}
interface OutputFile {
    name: string;
    writeByteOrderMark: boolean;
    text: string;
}
enum EndOfLineState {
    None = 0,
    InMultiLineCommentTrivia = 1,
    InSingleQuoteStringLiteral = 2,
    InDoubleQuoteStringLiteral = 3,
    InTemplateHeadOrNoSubstitutionTemplate = 4,
    InTemplateMiddleOrTail = 5,
    InTemplateSubstitutionPosition = 6,
}
enum TokenClass {
    Punctuation = 0,
    Keyword = 1,
    Operator = 2,
    Comment = 3,
    Whitespace = 4,
    Identifier = 5,
    NumberLiteral = 6,
    StringLiteral = 7,
    RegExpLiteral = 8,
}
interface ClassificationResult {
    finalLexState: EndOfLineState;
    entries: ClassificationInfo[];
}
interface ClassificationInfo {
    length: number;
    classification: TokenClass;
}
interface Classifier {
    /**
     * Gives lexical classifications of tokens on a line without any syntactic context.
     * For instance, a token consisting of the text 'string' can be either an identifier
     * named 'string' or the keyword 'string', however, because this classifier is not aware,
     * it relies on certain heuristics to give acceptable results. For classifications where
     * speed trumps accuracy, this function is preferable; however, for true accuracy, the
     * syntactic classifier is ideal. In fact, in certain editing scenarios, combining the
     * lexical, syntactic, and semantic classifiers may issue the best user experience.
     *
     * @param text                      The text of a line to classify.
     * @param lexState                  The state of the lexical classifier at the end of the previous line.
     * @param syntacticClassifierAbsent Whether the client is *not* using a syntactic classifier.
     *                                  If there is no syntactic classifier (syntacticClassifierAbsent=true),
     *                                  certain heuristics may be used in its place; however, if there is a
     *                                  syntactic classifier (syntacticClassifierAbsent=false), certain
     *                                  classifications which may be incorrectly categorized will be given
     *                                  back as Identifiers in order to allow the syntactic classifier to
     *                                  subsume the classification.
     * @deprecated Use getLexicalClassifications instead.
     */
    getClassificationsForLine(text: string, lexState: EndOfLineState, syntacticClassifierAbsent: boolean): ClassificationResult;
    getEncodedLexicalClassifications(text: string, endOfLineState: EndOfLineState, syntacticClassifierAbsent: boolean): Classifications;
}
namespace ScriptElementKind {
    const unknown = "";
    const warning = "warning";
    /** predefined type (void) or keyword (class) */
    const keyword = "keyword";
    /** top level script node */
    const scriptElement = "script";
    /** module foo {} */
    const moduleElement = "module";
    /** class X {} */
    const classElement = "class";
    /** var x = class X {} */
    const localClassElement = "local class";
    /** interface Y {} */
    const interfaceElement = "interface";
    /** type T = ... */
    const typeElement = "type";
    /** enum E */
    const enumElement = "enum";
    const enumMemberElement = "const";
    /**
     * Inside module and script only
     * const v = ..
     */
    const variableElement = "var";
    /** Inside function */
    const localVariableElement = "local var";
    /**
     * Inside module and script only
     * function f() { }
     */
    const functionElement = "function";
    /** Inside function */
    const localFunctionElement = "local function";
    /** class X { [public|private]* foo() {} } */
    const memberFunctionElement = "method";
    /** class X { [public|private]* [get|set] foo:number; } */
    const memberGetAccessorElement = "getter";
    const memberSetAccessorElement = "setter";
    /**
     * class X { [public|private]* foo:number; }
     * interface Y { foo:number; }
     */
    const memberVariableElement = "property";
    /** class X { constructor() { } } */
    const constructorImplementationElement = "constructor";
    /** interface Y { ():number; } */
    const callSignatureElement = "call";
    /** interface Y { []:number; } */
    const indexSignatureElement = "index";
    /** interface Y { new():Y; } */
    const constructSignatureElement = "construct";
    /** function foo(*Y*: string) */
    const parameterElement = "parameter";
    const typeParameterElement = "type parameter";
    const primitiveType = "primitive type";
    const label = "label";
    const alias = "alias";
    const constElement = "const";
    const letElement = "let";
    const directory = "directory";
    const externalModuleName = "external module name";
}
namespace ScriptElementKindModifier {
    const none = "";
    const publicMemberModifier = "public";
    const privateMemberModifier = "private";
    const protectedMemberModifier = "protected";
    const exportedModifier = "export";
    const ambientModifier = "declare";
    const staticModifier = "static";
    const abstractModifier = "abstract";
}
class ClassificationTypeNames {
    static comment: string;
    static identifier: string;
    static keyword: string;
    static numericLiteral: string;
    static operator: string;
    static stringLiteral: string;
    static whiteSpace: string;
    static text: string;
    static punctuation: string;
    static className: string;
    static enumName: string;
    static interfaceName: string;
    static moduleName: string;
    static typeParameterName: string;
    static typeAliasName: string;
    static parameterName: string;
    static docCommentTagName: string;
    static jsxOpenTagName: string;
    static jsxCloseTagName: string;
    static jsxSelfClosingTagName: string;
    static jsxAttribute: string;
    static jsxText: string;
    static jsxAttributeStringLiteralValue: string;
}
enum ClassificationType {
    comment = 1,
    identifier = 2,
    keyword = 3,
    numericLiteral = 4,
    operator = 5,
    stringLiteral = 6,
    regularExpressionLiteral = 7,
    whiteSpace = 8,
    text = 9,
    punctuation = 10,
    className = 11,
    enumName = 12,
    interfaceName = 13,
    moduleName = 14,
    typeParameterName = 15,
    typeAliasName = 16,
    parameterName = 17,
    docCommentTagName = 18,
    jsxOpenTagName = 19,
    jsxCloseTagName = 20,
    jsxSelfClosingTagName = 21,
    jsxAttribute = 22,
    jsxText = 23,
    jsxAttributeStringLiteralValue = 24,
}

} declare namespace ts {

function createClassifier(): Classifier;

} declare namespace ts {

/**
  * The document registry represents a store of SourceFile objects that can be shared between
  * multiple LanguageService instances. A LanguageService instance holds on the SourceFile (AST)
  * of files in the context.
  * SourceFile objects account for most of the memory usage by the language service. Sharing
  * the same DocumentRegistry instance between different instances of LanguageService allow
  * for more efficient memory utilization since all projects will share at least the library
  * file (lib.d.ts).
  *
  * A more advanced use of the document registry is to serialize sourceFile objects to disk
  * and re-hydrate them when needed.
  *
  * To create a default DocumentRegistry, use createDocumentRegistry to create one, and pass it
  * to all subsequent createLanguageService calls.
  */
interface DocumentRegistry {
    /**
      * Request a stored SourceFile with a given fileName and compilationSettings.
      * The first call to acquire will call createLanguageServiceSourceFile to generate
      * the SourceFile if was not found in the registry.
      *
      * @param fileName The name of the file requested
      * @param compilationSettings Some compilation settings like target affects the
      * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
      * multiple copies of the same file for different compilation settings.
      * @parm scriptSnapshot Text of the file. Only used if the file was not found
      * in the registry and a new one was created.
      * @parm version Current version of the file. Only used if the file was not found
      * in the registry and a new one was created.
      */
    acquireDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
    acquireDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
    /**
      * Request an updated version of an already existing SourceFile with a given fileName
      * and compilationSettings. The update will in-turn call updateLanguageServiceSourceFile
      * to get an updated SourceFile.
      *
      * @param fileName The name of the file requested
      * @param compilationSettings Some compilation settings like target affects the
      * shape of a the resulting SourceFile. This allows the DocumentRegistry to store
      * multiple copies of the same file for different compilation settings.
      * @param scriptSnapshot Text of the file.
      * @param version Current version of the file.
      */
    updateDocument(fileName: string, compilationSettings: CompilerOptions, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
    updateDocumentWithKey(fileName: string, path: Path, compilationSettings: CompilerOptions, key: DocumentRegistryBucketKey, scriptSnapshot: IScriptSnapshot, version: string, scriptKind?: ScriptKind): SourceFile;
    getKeyForCompilationSettings(settings: CompilerOptions): DocumentRegistryBucketKey;
    /**
      * Informs the DocumentRegistry that a file is not needed any longer.
      *
      * Note: It is not allowed to call release on a SourceFile that was not acquired from
      * this registry originally.
      *
      * @param fileName The name of the file to be released
      * @param compilationSettings The compilation settings used to acquire the file
      */
    releaseDocument(fileName: string, compilationSettings: CompilerOptions): void;
    releaseDocumentWithKey(path: Path, key: DocumentRegistryBucketKey): void;
    reportStats(): string;
}
type DocumentRegistryBucketKey = string & {
    __bucketKey: any;
};
function createDocumentRegistry(useCaseSensitiveFileNames?: boolean, currentDirectory?: string): DocumentRegistry;

} declare namespace ts {

function preProcessFile(sourceText: string, readImportFiles?: boolean, detectJavaScriptImports?: boolean): PreProcessedFileInfo;

} declare namespace ts {

interface TranspileOptions {
    compilerOptions?: CompilerOptions;
    fileName?: string;
    reportDiagnostics?: boolean;
    moduleName?: string;
    renamedDependencies?: MapLike<string>;
}
interface TranspileOutput {
    outputText: string;
    diagnostics?: Diagnostic[];
    sourceMapText?: string;
}
function transpileModule(input: string, transpileOptions: TranspileOptions): TranspileOutput;
function transpile(input: string, compilerOptions?: CompilerOptions, fileName?: string, diagnostics?: Diagnostic[], moduleName?: string): string;

} declare namespace ts {

/** The version of the language service API */
const servicesVersion = "0.5";
interface DisplayPartsSymbolWriter extends SymbolWriter {
    displayParts(): SymbolDisplayPart[];
}
function toEditorSettings(options: EditorOptions | EditorSettings): EditorSettings;
function displayPartsToString(displayParts: SymbolDisplayPart[]): string;
function getDefaultCompilerOptions(): CompilerOptions;
function getSupportedCodeFixes(): string[];
function createLanguageServiceSourceFile(fileName: string, scriptSnapshot: IScriptSnapshot, scriptTarget: ScriptTarget, version: string, setNodeParents: boolean, scriptKind?: ScriptKind): SourceFile;
let disableIncrementalParsing: boolean;
function updateLanguageServiceSourceFile(sourceFile: SourceFile, scriptSnapshot: IScriptSnapshot, version: string, textChangeRange: TextChangeRange, aggressiveChecks?: boolean): SourceFile;
function createLanguageService(host: LanguageServiceHost, documentRegistry?: DocumentRegistry): LanguageService;
/**
  * Get the path of the default library files (lib.d.ts) as distributed with the typescript
  * node package.
  * The functionality is not supported if the ts module is consumed outside of a node module.
  */
function getDefaultLibFilePath(options: CompilerOptions): string;

}