ts-simple-ast

declare enum SyntaxKind { Unknown = 0, EndOfFileToken = 1, SingleLineCommentTrivia = 2, MultiLineCommentTrivia = 3, NewLineTrivia = 4, WhitespaceTrivia = 5, ShebangTrivia = 6, ConflictMarkerTrivia = 7, NumericLiteral = 8, StringLiteral = 9, JsxText = 10, JsxTextAllWhiteSpaces = 11, RegularExpressionLiteral = 12, NoSubstitutionTemplateLiteral = 13, TemplateHead = 14, TemplateMiddle = 15, TemplateTail = 16, OpenBraceToken = 17, CloseBraceToken = 18, OpenParenToken = 19, CloseParenToken = 20, OpenBracketToken = 21, CloseBracketToken = 22, DotToken = 23, DotDotDotToken = 24, SemicolonToken = 25, CommaToken = 26, LessThanToken = 27, LessThanSlashToken = 28, GreaterThanToken = 29, LessThanEqualsToken = 30, GreaterThanEqualsToken = 31, EqualsEqualsToken = 32, ExclamationEqualsToken = 33, EqualsEqualsEqualsToken = 34, ExclamationEqualsEqualsToken = 35, EqualsGreaterThanToken = 36, PlusToken = 37, MinusToken = 38, AsteriskToken = 39, AsteriskAsteriskToken = 40, SlashToken = 41, PercentToken = 42, PlusPlusToken = 43, MinusMinusToken = 44, LessThanLessThanToken = 45, GreaterThanGreaterThanToken = 46, GreaterThanGreaterThanGreaterThanToken = 47, AmpersandToken = 48, BarToken = 49, CaretToken = 50, ExclamationToken = 51, TildeToken = 52, AmpersandAmpersandToken = 53, BarBarToken = 54, QuestionToken = 55, ColonToken = 56, AtToken = 57, EqualsToken = 58, PlusEqualsToken = 59, MinusEqualsToken = 60, AsteriskEqualsToken = 61, AsteriskAsteriskEqualsToken = 62, SlashEqualsToken = 63, PercentEqualsToken = 64, LessThanLessThanEqualsToken = 65, GreaterThanGreaterThanEqualsToken = 66, GreaterThanGreaterThanGreaterThanEqualsToken = 67, AmpersandEqualsToken = 68, BarEqualsToken = 69, CaretEqualsToken = 70, Identifier = 71, BreakKeyword = 72, CaseKeyword = 73, CatchKeyword = 74, ClassKeyword = 75, ConstKeyword = 76, ContinueKeyword = 77, DebuggerKeyword = 78, DefaultKeyword = 79, DeleteKeyword = 80, DoKeyword = 81, ElseKeyword = 82, EnumKeyword = 83, ExportKeyword = 84, ExtendsKeyword = 85, FalseKeyword = 86, FinallyKeyword = 87, ForKeyword = 88, FunctionKeyword = 89, IfKeyword = 90, ImportKeyword = 91, InKeyword = 92, InstanceOfKeyword = 93, NewKeyword = 94, NullKeyword = 95, ReturnKeyword = 96, SuperKeyword = 97, SwitchKeyword = 98, ThisKeyword = 99, ThrowKeyword = 100, TrueKeyword = 101, TryKeyword = 102, TypeOfKeyword = 103, VarKeyword = 104, VoidKeyword = 105, WhileKeyword = 106, WithKeyword = 107, ImplementsKeyword = 108, InterfaceKeyword = 109, LetKeyword = 110, PackageKeyword = 111, PrivateKeyword = 112, ProtectedKeyword = 113, PublicKeyword = 114, StaticKeyword = 115, YieldKeyword = 116, AbstractKeyword = 117, AsKeyword = 118, AnyKeyword = 119, AsyncKeyword = 120, AwaitKeyword = 121, BooleanKeyword = 122, ConstructorKeyword = 123, DeclareKeyword = 124, GetKeyword = 125, InferKeyword = 126, IsKeyword = 127, KeyOfKeyword = 128, ModuleKeyword = 129, NamespaceKeyword = 130, NeverKeyword = 131, ReadonlyKeyword = 132, RequireKeyword = 133, NumberKeyword = 134, ObjectKeyword = 135, SetKeyword = 136, StringKeyword = 137, SymbolKeyword = 138, TypeKeyword = 139, UndefinedKeyword = 140, UniqueKeyword = 141, FromKeyword = 142, GlobalKeyword = 143, OfKeyword = 144, QualifiedName = 145, ComputedPropertyName = 146, TypeParameter = 147, Parameter = 148, Decorator = 149, PropertySignature = 150, PropertyDeclaration = 151, MethodSignature = 152, MethodDeclaration = 153, Constructor = 154, GetAccessor = 155, SetAccessor = 156, CallSignature = 157, ConstructSignature = 158, IndexSignature = 159, TypePredicate = 160, TypeReference = 161, FunctionType = 162, ConstructorType = 163, TypeQuery = 164, TypeLiteral = 165, ArrayType = 166, TupleType = 167, UnionType = 168, IntersectionType = 169, ConditionalType = 170, InferType = 171, ParenthesizedType = 172, ThisType = 173, TypeOperator = 174, IndexedAccessType = 175, MappedType = 176, LiteralType = 177, ImportType = 178, ObjectBindingPattern = 179, ArrayBindingPattern = 180, BindingElement = 181, ArrayLiteralExpression = 182, ObjectLiteralExpression = 183, PropertyAccessExpression = 184, ElementAccessExpression = 185, CallExpression = 186, NewExpression = 187, TaggedTemplateExpression = 188, TypeAssertionExpression = 189, ParenthesizedExpression = 190, FunctionExpression = 191, ArrowFunction = 192, DeleteExpression = 193, TypeOfExpression = 194, VoidExpression = 195, AwaitExpression = 196, PrefixUnaryExpression = 197, PostfixUnaryExpression = 198, BinaryExpression = 199, ConditionalExpression = 200, TemplateExpression = 201, YieldExpression = 202, SpreadElement = 203, ClassExpression = 204, OmittedExpression = 205, ExpressionWithTypeArguments = 206, AsExpression = 207, NonNullExpression = 208, MetaProperty = 209, TemplateSpan = 210, SemicolonClassElement = 211, Block = 212, VariableStatement = 213, EmptyStatement = 214, ExpressionStatement = 215, IfStatement = 216, DoStatement = 217, WhileStatement = 218, ForStatement = 219, ForInStatement = 220, ForOfStatement = 221, ContinueStatement = 222, BreakStatement = 223, ReturnStatement = 224, WithStatement = 225, SwitchStatement = 226, LabeledStatement = 227, ThrowStatement = 228, TryStatement = 229, DebuggerStatement = 230, VariableDeclaration = 231, VariableDeclarationList = 232, FunctionDeclaration = 233, ClassDeclaration = 234, InterfaceDeclaration = 235, TypeAliasDeclaration = 236, EnumDeclaration = 237, ModuleDeclaration = 238, ModuleBlock = 239, CaseBlock = 240, NamespaceExportDeclaration = 241, ImportEqualsDeclaration = 242, ImportDeclaration = 243, ImportClause = 244, NamespaceImport = 245, NamedImports = 246, ImportSpecifier = 247, ExportAssignment = 248, ExportDeclaration = 249, NamedExports = 250, ExportSpecifier = 251, MissingDeclaration = 252, ExternalModuleReference = 253, JsxElement = 254, JsxSelfClosingElement = 255, JsxOpeningElement = 256, JsxClosingElement = 257, JsxFragment = 258, JsxOpeningFragment = 259, JsxClosingFragment = 260, JsxAttribute = 261, JsxAttributes = 262, JsxSpreadAttribute = 263, JsxExpression = 264, CaseClause = 265, DefaultClause = 266, HeritageClause = 267, CatchClause = 268, PropertyAssignment = 269, ShorthandPropertyAssignment = 270, SpreadAssignment = 271, EnumMember = 272, SourceFile = 273, Bundle = 274, UnparsedSource = 275, InputFiles = 276, JSDocTypeExpression = 277, JSDocAllType = 278, JSDocUnknownType = 279, JSDocNullableType = 280, JSDocNonNullableType = 281, JSDocOptionalType = 282, JSDocFunctionType = 283, JSDocVariadicType = 284, JSDocComment = 285, JSDocTypeLiteral = 286, JSDocSignature = 287, JSDocTag = 288, JSDocAugmentsTag = 289, JSDocClassTag = 290, JSDocCallbackTag = 291, JSDocParameterTag = 292, JSDocReturnTag = 293, JSDocTypeTag = 294, JSDocTemplateTag = 295, JSDocTypedefTag = 296, JSDocPropertyTag = 297, SyntaxList = 298, NotEmittedStatement = 299, PartiallyEmittedExpression = 300, CommaListExpression = 301, MergeDeclarationMarker = 302, EndOfDeclarationMarker = 303, Count = 304, FirstAssignment = 58, LastAssignment = 70, FirstCompoundAssignment = 59, LastCompoundAssignment = 70, FirstReservedWord = 72, LastReservedWord = 107, FirstKeyword = 72, LastKeyword = 144, FirstFutureReservedWord = 108, LastFutureReservedWord = 116, FirstTypeNode = 160, LastTypeNode = 178, FirstPunctuation = 17, LastPunctuation = 70, FirstToken = 0, LastToken = 144, FirstTriviaToken = 2, LastTriviaToken = 7, FirstLiteralToken = 8, LastLiteralToken = 13, FirstTemplateToken = 13, LastTemplateToken = 16, FirstBinaryOperator = 27, LastBinaryOperator = 70, FirstNode = 145, FirstJSDocNode = 277, LastJSDocNode = 297, FirstJSDocTagNode = 288, LastJSDocTagNode = 297 } declare enum TypeFormatFlags { None = 0, NoTruncation = 1, WriteArrayAsGenericType = 2, UseStructuralFallback = 8, WriteTypeArgumentsOfSignature = 32, UseFullyQualifiedType = 64, SuppressAnyReturnType = 256, MultilineObjectLiterals = 1024, WriteClassExpressionAsTypeLiteral = 2048, UseTypeOfFunction = 4096, OmitParameterModifiers = 8192, UseAliasDefinedOutsideCurrentScope = 16384, AllowUniqueESSymbolType = 1048576, AddUndefined = 131072, WriteArrowStyleSignature = 262144, InArrayType = 524288, InElementType = 2097152, InFirstTypeArgument = 4194304, InTypeAlias = 8388608, /** * @deprecated */ WriteOwnNameForAnyLike = 0, NodeBuilderFlagsMask = 9469291 } declare 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, Alias = 2097152, Prototype = 4194304, ExportStar = 8388608, Optional = 16777216, Transient = 33554432, JSContainer = 67108864, Enum = 384, Variable = 3, Value = 67216319, Type = 67901928, Namespace = 1920, Module = 1536, Accessor = 98304, FunctionScopedVariableExcludes = 67216318, BlockScopedVariableExcludes = 67216319, ParameterExcludes = 67216319, PropertyExcludes = 0, EnumMemberExcludes = 68008959, FunctionExcludes = 67215791, ClassExcludes = 68008383, InterfaceExcludes = 67901832, RegularEnumExcludes = 68008191, ConstEnumExcludes = 68008831, ValueModuleExcludes = 67215503, NamespaceModuleExcludes = 0, MethodExcludes = 67208127, GetAccessorExcludes = 67150783, SetAccessorExcludes = 67183551, TypeParameterExcludes = 67639784, TypeAliasExcludes = 67901928, AliasExcludes = 2097152, ModuleMember = 2623475, ExportHasLocal = 944, HasExports = 1952, HasMembers = 6240, BlockScoped = 418, PropertyOrAccessor = 98308, ClassMember = 106500 } declare enum TypeFlags { Any = 1, String = 2, Number = 4, Boolean = 8, Enum = 16, StringLiteral = 32, NumberLiteral = 64, BooleanLiteral = 128, EnumLiteral = 256, ESSymbol = 512, UniqueESSymbol = 1024, Void = 2048, Undefined = 4096, Null = 8192, Never = 16384, TypeParameter = 32768, Object = 65536, Union = 131072, Intersection = 262144, Index = 524288, IndexedAccess = 1048576, Conditional = 2097152, Substitution = 4194304, NonPrimitive = 134217728, Literal = 224, Unit = 13536, StringOrNumberLiteral = 96, PossiblyFalsy = 14574, StringLike = 34, NumberLike = 84, BooleanLike = 136, EnumLike = 272, ESSymbolLike = 1536, VoidLike = 6144, UnionOrIntersection = 393216, StructuredType = 458752, TypeVariable = 1081344, InstantiableNonPrimitive = 7372800, InstantiablePrimitive = 524288, Instantiable = 7897088, StructuredOrInstantiable = 8355840, Narrowable = 142575359, NotUnionOrUnit = 134283777 } declare enum ObjectFlags { Class = 1, Interface = 2, Reference = 4, Tuple = 8, Anonymous = 16, Mapped = 32, Instantiated = 64, ObjectLiteral = 128, EvolvingArray = 256, ObjectLiteralPatternWithComputedProperties = 512, ContainsSpread = 1024, ReverseMapped = 2048, JsxAttributes = 4096, MarkerType = 8192, ClassOrInterface = 3 } declare enum DiagnosticCategory { Warning = 0, Error = 1, Suggestion = 2, Message = 3 } declare enum ModuleResolutionKind { Classic = 1, NodeJs = 2 } declare enum ModuleKind { None = 0, CommonJS = 1, AMD = 2, UMD = 3, System = 4, ES2015 = 5, ESNext = 6 } declare enum JsxEmit { None = 0, Preserve = 1, React = 2, ReactNative = 3 } declare enum NewLineKind { CarriageReturnLineFeed = 0, LineFeed = 1 } declare enum ScriptKind { Unknown = 0, JS = 1, JSX = 2, TS = 3, TSX = 4, External = 5, JSON = 6, /** * Used on extensions that doesn't define the ScriptKind but the content defines it. * Deferred extensions are going to be included in all project contexts. */ Deferred = 7 } declare enum ScriptTarget { ES3 = 0, ES5 = 1, ES2015 = 2, ES2016 = 3, ES2017 = 4, ES2018 = 5, ESNext = 6, JSON = 100, Latest = 6 } declare enum LanguageVariant { Standard = 0, JSX = 1 } declare enum EmitHint { SourceFile = 0, Expression = 1, IdentifierName = 2, MappedTypeParameter = 3, Unspecified = 4 } declare enum IndentStyle { None = 0, Block = 1, Smart = 2 } /** * Type of objects whose values are all of the same type. * The `in` and `for-in` operators can *not* be safely used, * since `Object.prototype` may be modified by outside code. */ export interface MapLike<T> { [index: string]: T; } export interface CompilerOptions { [option: string]: ts.CompilerOptionsValue | ts.TsConfigSourceFile | undefined; allowJs?: boolean; allowSyntheticDefaultImports?: boolean; allowUnreachableCode?: boolean; allowUnusedLabels?: boolean; alwaysStrict?: boolean; baseUrl?: string; charset?: string; checkJs?: boolean; declaration?: boolean; declarationMap?: boolean; emitDeclarationOnly?: boolean; declarationDir?: string; disableSizeLimit?: boolean; downlevelIteration?: boolean; emitBOM?: boolean; emitDecoratorMetadata?: boolean; experimentalDecorators?: boolean; forceConsistentCasingInFileNames?: boolean; importHelpers?: boolean; inlineSourceMap?: boolean; inlineSources?: boolean; isolatedModules?: boolean; jsx?: JsxEmit; keyofStringsOnly?: boolean; 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; noStrictGenericChecks?: boolean; noUnusedLocals?: boolean; noUnusedParameters?: boolean; noImplicitUseStrict?: boolean; noLib?: boolean; noResolve?: boolean; out?: string; outDir?: string; outFile?: string; paths?: MapLike<string[]>; preserveConstEnums?: boolean; preserveSymlinks?: boolean; project?: string; reactNamespace?: string; jsxFactory?: string; composite?: boolean; removeComments?: boolean; rootDir?: string; rootDirs?: string[]; skipLibCheck?: boolean; skipDefaultLibCheck?: boolean; sourceMap?: boolean; sourceRoot?: string; strict?: boolean; strictFunctionTypes?: boolean; strictNullChecks?: boolean; strictPropertyInitialization?: boolean; suppressExcessPropertyErrors?: boolean; suppressImplicitAnyIndexErrors?: boolean; target?: ScriptTarget; traceResolution?: boolean; resolveJsonModule?: boolean; types?: string[]; /** * Paths used to compute primary types search locations */ typeRoots?: string[]; esModuleInterop?: boolean; } export interface EditorSettings { baseIndentSize?: number; indentSize?: number; tabSize?: number; newLineCharacter?: string; convertTabsToSpaces?: boolean; indentStyle?: IndentStyle; } export declare namespace ts { namespace ScriptSnapshot { function fromString(text: string): IScriptSnapshot; } /** * ES6 Map interface, only read methods included. */ interface ReadonlyMap<T> { size: number; get(key: string): T | undefined; has(key: string): boolean; forEach(action: (value: T, key: string) => void): void; keys(): Iterator<string>; values(): Iterator<T>; entries(): Iterator<[string, T]>; } /** * ES6 Map interface. */ interface Map<T> extends ReadonlyMap<T> { set(key: string, value: T): this; delete(key: string): boolean; clear(): void; } /** * ES6 Iterator type. */ interface Iterator<T> { next(): { value: T; done: false; } | { value: never; done: true; }; } /** * Array that is only intended to be pushed to, never read. */ interface Push<T> { push(values: T[]): void; } interface TextRange { pos: number; end: number; } interface Node extends TextRange { kind: SyntaxKind; flags: NodeFlags; decorators?: NodeArray<Decorator>; modifiers?: ModifiersArray; parent?: Node; /** * This brand prevents using nodes not created within this library or not created within the ts namespace object of this library. * It's recommended that you only use this library and use its ts named export for all your TypeScript compiler needs. * If you want to ignore this and are using the same TypeScript compiler version as ts.versionMajorMinor then assert it to ts.Node. * If you don't use this library with this same major & minor version of TypeScript then be warned, you may encounter unexpected behaviour. */ _tsSimpleAstBrand: undefined; } interface JSDocContainer { } interface NodeArray<T extends Node> extends ReadonlyArray<T>, TextRange { hasTrailingComma?: boolean; } interface Token<TKind extends SyntaxKind> extends Node { kind: TKind; } interface Identifier extends PrimaryExpression, Declaration { kind: SyntaxKind.Identifier; /** * Prefer to use `id.unescapedText`. (Note: This is available only in services, not internally to the TypeScript compiler.) * Text of identifier, but if the identifier begins with two underscores, this will begin with three. */ escapedText: __String; originalKeywordKind?: SyntaxKind; isInJSDocNamespace?: boolean; } interface TransientIdentifier extends Identifier { resolvedSymbol: Symbol; } interface QualifiedName extends Node { kind: SyntaxKind.QualifiedName; left: EntityName; right: Identifier; } interface Declaration extends Node { _declarationBrand: any; } interface NamedDeclaration extends Declaration { name?: DeclarationName; } interface DeclarationStatement extends NamedDeclaration, Statement { name?: Identifier | StringLiteral | NumericLiteral; } interface ComputedPropertyName extends Node { kind: SyntaxKind.ComputedPropertyName; expression: Expression; } interface Decorator extends Node { kind: SyntaxKind.Decorator; parent?: NamedDeclaration; expression: LeftHandSideExpression; } interface TypeParameterDeclaration extends NamedDeclaration { kind: SyntaxKind.TypeParameter; parent?: DeclarationWithTypeParameters | InferTypeNode; name: Identifier; constraint?: TypeNode; default?: TypeNode; expression?: Expression; } interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer { kind: SignatureDeclaration["kind"]; name?: PropertyName; typeParameters?: NodeArray<TypeParameterDeclaration>; parameters: NodeArray<ParameterDeclaration>; type: TypeNode | undefined; } interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement { kind: SyntaxKind.CallSignature; } interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement { kind: SyntaxKind.ConstructSignature; } interface VariableDeclaration extends NamedDeclaration { kind: SyntaxKind.VariableDeclaration; parent?: VariableDeclarationList | CatchClause; name: BindingName; exclamationToken?: ExclamationToken; type?: TypeNode; initializer?: Expression; } interface VariableDeclarationList extends Node { kind: SyntaxKind.VariableDeclarationList; parent?: VariableStatement | ForStatement | ForOfStatement | ForInStatement; declarations: NodeArray<VariableDeclaration>; } interface ParameterDeclaration extends NamedDeclaration, JSDocContainer { kind: SyntaxKind.Parameter; parent?: SignatureDeclaration; dotDotDotToken?: DotDotDotToken; name: BindingName; questionToken?: QuestionToken; type?: TypeNode; initializer?: Expression; } interface BindingElement extends NamedDeclaration { kind: SyntaxKind.BindingElement; parent?: BindingPattern; propertyName?: PropertyName; dotDotDotToken?: DotDotDotToken; name: BindingName; initializer?: Expression; } interface PropertySignature extends TypeElement, JSDocContainer { kind: SyntaxKind.PropertySignature; name: PropertyName; questionToken?: QuestionToken; type?: TypeNode; initializer?: Expression; } interface PropertyDeclaration extends ClassElement, JSDocContainer { kind: SyntaxKind.PropertyDeclaration; parent: ClassLikeDeclaration; name: PropertyName; questionToken?: QuestionToken; exclamationToken?: ExclamationToken; type?: TypeNode; initializer?: Expression; } interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrandBrand: any; name?: PropertyName; } interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer { parent: ObjectLiteralExpression; kind: SyntaxKind.PropertyAssignment; name: PropertyName; questionToken?: QuestionToken; initializer: Expression; } interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer { parent: ObjectLiteralExpression; kind: SyntaxKind.ShorthandPropertyAssignment; name: Identifier; questionToken?: QuestionToken; equalsToken?: Token<SyntaxKind.EqualsToken>; objectAssignmentInitializer?: Expression; } interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer { parent: ObjectLiteralExpression; kind: SyntaxKind.SpreadAssignment; expression: Expression; } interface PropertyLikeDeclaration extends NamedDeclaration { name: PropertyName; } interface ObjectBindingPattern extends Node { kind: SyntaxKind.ObjectBindingPattern; parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray<BindingElement>; } interface ArrayBindingPattern extends Node { kind: SyntaxKind.ArrayBindingPattern; parent?: VariableDeclaration | ParameterDeclaration | BindingElement; elements: NodeArray<ArrayBindingElement>; } /** * Several node kinds share function-like features such as a signature, * a name, and a body. These nodes should extend FunctionLikeDeclarationBase. * Examples: * - FunctionDeclaration * - MethodDeclaration * - AccessorDeclaration */ interface FunctionLikeDeclarationBase extends SignatureDeclarationBase { _functionLikeDeclarationBrand: any; asteriskToken?: AsteriskToken; questionToken?: QuestionToken; body?: Block | Expression; } interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement { kind: SyntaxKind.FunctionDeclaration; name?: Identifier; body?: FunctionBody; } interface MethodSignature extends SignatureDeclarationBase, TypeElement { kind: SyntaxKind.MethodSignature; parent?: ObjectTypeDeclaration; name: PropertyName; } interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer { kind: SyntaxKind.MethodDeclaration; parent?: ClassLikeDeclaration | ObjectLiteralExpression; name: PropertyName; body?: FunctionBody; } interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer { kind: SyntaxKind.Constructor; parent?: ClassLikeDeclaration; body?: FunctionBody; } /** * For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */ interface SemicolonClassElement extends ClassElement { kind: SyntaxKind.SemicolonClassElement; parent?: ClassLikeDeclaration; } interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer { kind: SyntaxKind.GetAccessor; parent?: ClassLikeDeclaration | ObjectLiteralExpression; name: PropertyName; body?: FunctionBody; } interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer { kind: SyntaxKind.SetAccessor; parent?: ClassLikeDeclaration | ObjectLiteralExpression; name: PropertyName; body?: FunctionBody; } interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement { kind: SyntaxKind.IndexSignature; parent?: ObjectTypeDeclaration; } interface TypeNode extends Node { _typeNodeBrand: any; } interface KeywordTypeNode extends TypeNode { kind: SyntaxKind.AnyKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.VoidKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.NullKeyword | SyntaxKind.NeverKeyword; } interface ImportTypeNode extends NodeWithTypeArguments { kind: SyntaxKind.ImportType; isTypeOf?: boolean; argument: TypeNode; qualifier?: EntityName; } interface ThisTypeNode extends TypeNode { kind: SyntaxKind.ThisType; } interface FunctionTypeNode extends TypeNode, SignatureDeclarationBase { kind: SyntaxKind.FunctionType; } interface ConstructorTypeNode extends TypeNode, SignatureDeclarationBase { kind: SyntaxKind.ConstructorType; } interface NodeWithTypeArguments extends TypeNode { typeArguments?: NodeArray<TypeNode>; } interface TypeReferenceNode extends NodeWithTypeArguments { kind: SyntaxKind.TypeReference; typeName: EntityName; } interface TypePredicateNode extends TypeNode { kind: SyntaxKind.TypePredicate; parent?: SignatureDeclaration; 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 UnionTypeNode extends TypeNode { kind: SyntaxKind.UnionType; types: NodeArray<TypeNode>; } interface IntersectionTypeNode extends TypeNode { kind: SyntaxKind.IntersectionType; types: NodeArray<TypeNode>; } interface ConditionalTypeNode extends TypeNode { kind: SyntaxKind.ConditionalType; checkType: TypeNode; extendsType: TypeNode; trueType: TypeNode; falseType: TypeNode; } interface InferTypeNode extends TypeNode { kind: SyntaxKind.InferType; typeParameter: TypeParameterDeclaration; } interface ParenthesizedTypeNode extends TypeNode { kind: SyntaxKind.ParenthesizedType; type: TypeNode; } interface TypeOperatorNode extends TypeNode { kind: SyntaxKind.TypeOperator; operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword; type: TypeNode; } interface IndexedAccessTypeNode extends TypeNode { kind: SyntaxKind.IndexedAccessType; objectType: TypeNode; indexType: TypeNode; } interface MappedTypeNode extends TypeNode, Declaration { kind: SyntaxKind.MappedType; readonlyToken?: ReadonlyToken | PlusToken | MinusToken; typeParameter: TypeParameterDeclaration; questionToken?: QuestionToken | PlusToken | MinusToken; type?: TypeNode; } interface LiteralTypeNode extends TypeNode { kind: SyntaxKind.LiteralType; literal: BooleanLiteral | LiteralExpression | PrefixUnaryExpression; } interface StringLiteral extends LiteralExpression { kind: SyntaxKind.StringLiteral; } interface Expression extends Node { _expressionBrand: any; } interface OmittedExpression extends Expression { kind: SyntaxKind.OmittedExpression; } interface PartiallyEmittedExpression extends LeftHandSideExpression { kind: SyntaxKind.PartiallyEmittedExpression; expression: Expression; } interface UnaryExpression extends Expression { _unaryExpressionBrand: any; } interface UpdateExpression extends UnaryExpression { _updateExpressionBrand: any; } interface PrefixUnaryExpression extends UpdateExpression { kind: SyntaxKind.PrefixUnaryExpression; operator: PrefixUnaryOperator; operand: UnaryExpression; } interface PostfixUnaryExpression extends UpdateExpression { kind: SyntaxKind.PostfixUnaryExpression; operand: LeftHandSideExpression; operator: PostfixUnaryOperator; } interface LeftHandSideExpression extends UpdateExpression { _leftHandSideExpressionBrand: any; } interface MemberExpression extends LeftHandSideExpression { _memberExpressionBrand: any; } interface PrimaryExpression extends MemberExpression { _primaryExpressionBrand: any; } interface NullLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.NullKeyword; } interface BooleanLiteral extends PrimaryExpression, TypeNode { kind: SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword; } interface ThisExpression extends PrimaryExpression, KeywordTypeNode { kind: SyntaxKind.ThisKeyword; } interface SuperExpression extends PrimaryExpression { kind: SyntaxKind.SuperKeyword; } interface ImportExpression extends PrimaryExpression { kind: SyntaxKind.ImportKeyword; } 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; } interface BinaryExpression extends Expression, Declaration { kind: SyntaxKind.BinaryExpression; left: Expression; operatorToken: BinaryOperatorToken; right: Expression; } 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; } interface ConditionalExpression extends Expression { kind: SyntaxKind.ConditionalExpression; condition: Expression; questionToken: QuestionToken; whenTrue: Expression; colonToken: ColonToken; whenFalse: Expression; } interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer { kind: SyntaxKind.FunctionExpression; name?: Identifier; body: FunctionBody; } interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer { kind: SyntaxKind.ArrowFunction; equalsGreaterThanToken: EqualsGreaterThanToken; body: ConciseBody; name: never; } 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; } interface TemplateHead extends LiteralLikeNode { kind: SyntaxKind.TemplateHead; parent?: TemplateExpression; } interface TemplateMiddle extends LiteralLikeNode { kind: SyntaxKind.TemplateMiddle; parent?: TemplateSpan; } interface TemplateTail extends LiteralLikeNode { kind: SyntaxKind.TemplateTail; parent?: TemplateSpan; } interface TemplateExpression extends PrimaryExpression { kind: SyntaxKind.TemplateExpression; head: TemplateHead; templateSpans: NodeArray<TemplateSpan>; } interface TemplateSpan extends Node { kind: SyntaxKind.TemplateSpan; parent?: TemplateExpression; expression: Expression; literal: TemplateMiddle | TemplateTail; } interface ParenthesizedExpression extends PrimaryExpression, JSDocContainer { kind: SyntaxKind.ParenthesizedExpression; expression: Expression; } interface ArrayLiteralExpression extends PrimaryExpression { kind: SyntaxKind.ArrayLiteralExpression; elements: NodeArray<Expression>; } interface SpreadElement extends Expression { kind: SyntaxKind.SpreadElement; parent?: ArrayLiteralExpression | CallExpression | NewExpression; 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; } interface PropertyAccessExpression extends MemberExpression, NamedDeclaration { 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; } interface CallExpression extends LeftHandSideExpression, Declaration { kind: SyntaxKind.CallExpression; expression: LeftHandSideExpression; typeArguments?: NodeArray<TypeNode>; arguments: NodeArray<Expression>; } interface SuperCall extends CallExpression { expression: SuperExpression; } interface ImportCall extends CallExpression { expression: ImportExpression; } interface ExpressionWithTypeArguments extends NodeWithTypeArguments { kind: SyntaxKind.ExpressionWithTypeArguments; parent?: HeritageClause; expression: LeftHandSideExpression; } 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; typeArguments?: NodeArray<TypeNode>; template: TemplateLiteral; } interface AsExpression extends Expression { kind: SyntaxKind.AsExpression; expression: Expression; type: TypeNode; } interface TypeAssertion extends UnaryExpression { kind: SyntaxKind.TypeAssertionExpression; type: TypeNode; expression: UnaryExpression; } interface NonNullExpression extends LeftHandSideExpression { kind: SyntaxKind.NonNullExpression; expression: Expression; } interface MetaProperty extends PrimaryExpression { kind: SyntaxKind.MetaProperty; keywordToken: SyntaxKind.NewKeyword | SyntaxKind.ImportKeyword; name: Identifier; } interface JsxElement extends PrimaryExpression { kind: SyntaxKind.JsxElement; openingElement: JsxOpeningElement; children: NodeArray<JsxChild>; closingElement: JsxClosingElement; } interface JsxAttributes extends ObjectLiteralExpressionBase<JsxAttributeLike> { parent?: JsxOpeningLikeElement; } interface JsxOpeningElement extends Expression { kind: SyntaxKind.JsxOpeningElement; parent?: JsxElement; tagName: JsxTagNameExpression; typeArguments?: NodeArray<TypeNode>; attributes: JsxAttributes; } interface JsxSelfClosingElement extends PrimaryExpression { kind: SyntaxKind.JsxSelfClosingElement; tagName: JsxTagNameExpression; typeArguments?: NodeArray<TypeNode>; attributes: JsxAttributes; } interface JsxFragment extends PrimaryExpression { kind: SyntaxKind.JsxFragment; openingFragment: JsxOpeningFragment; children: NodeArray<JsxChild>; closingFragment: JsxClosingFragment; } interface JsxOpeningFragment extends Expression { kind: SyntaxKind.JsxOpeningFragment; parent?: JsxFragment; } interface JsxClosingFragment extends Expression { kind: SyntaxKind.JsxClosingFragment; parent?: JsxFragment; } interface JsxAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxAttribute; parent?: JsxAttributes; name: Identifier; initializer?: StringLiteral | JsxExpression; } interface JsxSpreadAttribute extends ObjectLiteralElement { kind: SyntaxKind.JsxSpreadAttribute; parent?: JsxAttributes; expression: Expression; } interface JsxClosingElement extends Node { kind: SyntaxKind.JsxClosingElement; parent?: JsxElement; tagName: JsxTagNameExpression; } interface JsxExpression extends Expression { kind: SyntaxKind.JsxExpression; parent?: JsxElement | JsxAttributeLike; dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>; expression?: Expression; } interface JsxText extends Node { kind: SyntaxKind.JsxText; containsOnlyWhiteSpaces: boolean; parent?: JsxElement; } interface Statement extends Node { _statementBrand: any; } interface NotEmittedStatement extends Statement { kind: SyntaxKind.NotEmittedStatement; } /** * A list of comma-separated expressions. This node is only created by transformations. */ interface CommaListExpression extends Expression { kind: SyntaxKind.CommaListExpression; elements: NodeArray<Expression>; } interface EmptyStatement extends Statement { kind: SyntaxKind.EmptyStatement; } interface DebuggerStatement extends Statement { kind: SyntaxKind.DebuggerStatement; } interface MissingDeclaration extends DeclarationStatement { kind: SyntaxKind.MissingDeclaration; name?: Identifier; } interface Block extends Statement { kind: SyntaxKind.Block; statements: NodeArray<Statement>; } interface VariableStatement extends Statement, JSDocContainer { kind: SyntaxKind.VariableStatement; declarationList: VariableDeclarationList; } interface ExpressionStatement extends Statement, JSDocContainer { 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; } 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; awaitModifier?: AwaitKeywordToken; initializer: ForInitializer; expression: Expression; } interface BreakStatement extends Statement { kind: SyntaxKind.BreakStatement; label?: Identifier; } interface ContinueStatement extends Statement { kind: SyntaxKind.ContinueStatement; label?: Identifier; } 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; parent?: SwitchStatement; clauses: NodeArray<CaseOrDefaultClause>; } interface CaseClause extends Node { kind: SyntaxKind.CaseClause; parent?: CaseBlock; expression: Expression; statements: NodeArray<Statement>; } interface DefaultClause extends Node { kind: SyntaxKind.DefaultClause; parent?: CaseBlock; statements: NodeArray<Statement>; } interface LabeledStatement extends Statement, JSDocContainer { 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; parent?: TryStatement; variableDeclaration?: VariableDeclaration; block: Block; } interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer { kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression; name?: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; heritageClauses?: NodeArray<HeritageClause>; members: NodeArray<ClassElement>; } interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement { kind: SyntaxKind.ClassDeclaration; /** * May be undefined in `export default class { ... }`. */ name?: Identifier; } interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression { kind: SyntaxKind.ClassExpression; } interface ClassElement extends NamedDeclaration { _classElementBrand: any; name?: PropertyName; } interface TypeElement extends NamedDeclaration { _typeElementBrand: any; name?: PropertyName; questionToken?: QuestionToken; } interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer { kind: SyntaxKind.InterfaceDeclaration; name: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; heritageClauses?: NodeArray<HeritageClause>; members: NodeArray<TypeElement>; } interface HeritageClause extends Node { kind: SyntaxKind.HeritageClause; parent?: InterfaceDeclaration | ClassLikeDeclaration; token: SyntaxKind.ExtendsKeyword | SyntaxKind.ImplementsKeyword; types: NodeArray<ExpressionWithTypeArguments>; } interface TypeAliasDeclaration extends DeclarationStatement, JSDocContainer { kind: SyntaxKind.TypeAliasDeclaration; name: Identifier; typeParameters?: NodeArray<TypeParameterDeclaration>; type: TypeNode; }