react-native-flip
Version:
1,058 lines (1,055 loc) • 459 kB
TypeScript
/*! *****************************************************************************
Copyright (c) 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 http://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 {
const versionMajorMinor = "4.3";
/** The version of the TypeScript compiler release */
const version: string;
/**
* 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.
*/
interface MapLike<T> {
[index: string]: T;
}
interface SortedReadonlyArray<T> extends ReadonlyArray<T> {
" __sortedArrayBrand": any;
}
interface SortedArray<T> extends Array<T> {
" __sortedArrayBrand": any;
}
/** Common read methods for ES6 Map/Set. */
interface ReadonlyCollection<K> {
readonly size: number;
has(key: K): boolean;
keys(): Iterator<K>;
}
/** Common write methods for ES6 Map/Set. */
interface Collection<K> extends ReadonlyCollection<K> {
delete(key: K): boolean;
clear(): void;
}
/** ES6 Map interface, only read methods included. */
interface ReadonlyESMap<K, V> extends ReadonlyCollection<K> {
get(key: K): V | undefined;
values(): Iterator<V>;
entries(): Iterator<[K, V]>;
forEach(action: (value: V, key: K) => void): void;
}
/**
* ES6 Map interface, only read methods included.
*/
interface ReadonlyMap<T> extends ReadonlyESMap<string, T> {
}
/** ES6 Map interface. */
interface ESMap<K, V> extends ReadonlyESMap<K, V>, Collection<K> {
set(key: K, value: V): this;
}
/**
* ES6 Map interface.
*/
interface Map<T> extends ESMap<string, T> {
}
/** ES6 Set interface, only read methods included. */
interface ReadonlySet<T> extends ReadonlyCollection<T> {
has(value: T): boolean;
values(): Iterator<T>;
entries(): Iterator<[T, T]>;
forEach(action: (value: T, key: T) => void): void;
}
/** ES6 Set interface. */
interface Set<T> extends ReadonlySet<T>, Collection<T> {
add(value: T): this;
delete(value: T): boolean;
}
/** ES6 Iterator type. */
interface Iterator<T> {
next(): {
value: T;
done?: false;
} | {
value: void;
done: true;
};
}
/** Array that is only intended to be pushed to, never read. */
interface Push<T> {
push(...values: T[]): void;
}
}
declare namespace ts {
export type Path = string & {
__pathBrand: any;
};
export interface TextRange {
pos: number;
end: number;
}
export interface ReadonlyTextRange {
readonly pos: number;
readonly end: number;
}
export enum SyntaxKind {
Unknown = 0,
EndOfFileToken = 1,
SingleLineCommentTrivia = 2,
MultiLineCommentTrivia = 3,
NewLineTrivia = 4,
WhitespaceTrivia = 5,
ShebangTrivia = 6,
ConflictMarkerTrivia = 7,
NumericLiteral = 8,
BigIntLiteral = 9,
StringLiteral = 10,
JsxText = 11,
JsxTextAllWhiteSpaces = 12,
RegularExpressionLiteral = 13,
NoSubstitutionTemplateLiteral = 14,
TemplateHead = 15,
TemplateMiddle = 16,
TemplateTail = 17,
OpenBraceToken = 18,
CloseBraceToken = 19,
OpenParenToken = 20,
CloseParenToken = 21,
OpenBracketToken = 22,
CloseBracketToken = 23,
DotToken = 24,
DotDotDotToken = 25,
SemicolonToken = 26,
CommaToken = 27,
QuestionDotToken = 28,
LessThanToken = 29,
LessThanSlashToken = 30,
GreaterThanToken = 31,
LessThanEqualsToken = 32,
GreaterThanEqualsToken = 33,
EqualsEqualsToken = 34,
ExclamationEqualsToken = 35,
EqualsEqualsEqualsToken = 36,
ExclamationEqualsEqualsToken = 37,
EqualsGreaterThanToken = 38,
PlusToken = 39,
MinusToken = 40,
AsteriskToken = 41,
AsteriskAsteriskToken = 42,
SlashToken = 43,
PercentToken = 44,
PlusPlusToken = 45,
MinusMinusToken = 46,
LessThanLessThanToken = 47,
GreaterThanGreaterThanToken = 48,
GreaterThanGreaterThanGreaterThanToken = 49,
AmpersandToken = 50,
BarToken = 51,
CaretToken = 52,
ExclamationToken = 53,
TildeToken = 54,
AmpersandAmpersandToken = 55,
BarBarToken = 56,
QuestionToken = 57,
ColonToken = 58,
AtToken = 59,
QuestionQuestionToken = 60,
/** Only the JSDoc scanner produces BacktickToken. The normal scanner produces NoSubstitutionTemplateLiteral and related kinds. */
BacktickToken = 61,
EqualsToken = 62,
PlusEqualsToken = 63,
MinusEqualsToken = 64,
AsteriskEqualsToken = 65,
AsteriskAsteriskEqualsToken = 66,
SlashEqualsToken = 67,
PercentEqualsToken = 68,
LessThanLessThanEqualsToken = 69,
GreaterThanGreaterThanEqualsToken = 70,
GreaterThanGreaterThanGreaterThanEqualsToken = 71,
AmpersandEqualsToken = 72,
BarEqualsToken = 73,
BarBarEqualsToken = 74,
AmpersandAmpersandEqualsToken = 75,
QuestionQuestionEqualsToken = 76,
CaretEqualsToken = 77,
Identifier = 78,
PrivateIdentifier = 79,
BreakKeyword = 80,
CaseKeyword = 81,
CatchKeyword = 82,
ClassKeyword = 83,
ConstKeyword = 84,
ContinueKeyword = 85,
DebuggerKeyword = 86,
DefaultKeyword = 87,
DeleteKeyword = 88,
DoKeyword = 89,
ElseKeyword = 90,
EnumKeyword = 91,
ExportKeyword = 92,
ExtendsKeyword = 93,
FalseKeyword = 94,
FinallyKeyword = 95,
ForKeyword = 96,
FunctionKeyword = 97,
IfKeyword = 98,
ImportKeyword = 99,
InKeyword = 100,
InstanceOfKeyword = 101,
NewKeyword = 102,
NullKeyword = 103,
ReturnKeyword = 104,
SuperKeyword = 105,
SwitchKeyword = 106,
ThisKeyword = 107,
ThrowKeyword = 108,
TrueKeyword = 109,
TryKeyword = 110,
TypeOfKeyword = 111,
VarKeyword = 112,
VoidKeyword = 113,
WhileKeyword = 114,
WithKeyword = 115,
ImplementsKeyword = 116,
InterfaceKeyword = 117,
LetKeyword = 118,
PackageKeyword = 119,
PrivateKeyword = 120,
ProtectedKeyword = 121,
PublicKeyword = 122,
StaticKeyword = 123,
YieldKeyword = 124,
AbstractKeyword = 125,
AsKeyword = 126,
AssertsKeyword = 127,
AnyKeyword = 128,
AsyncKeyword = 129,
AwaitKeyword = 130,
BooleanKeyword = 131,
ConstructorKeyword = 132,
DeclareKeyword = 133,
GetKeyword = 134,
InferKeyword = 135,
IntrinsicKeyword = 136,
IsKeyword = 137,
KeyOfKeyword = 138,
ModuleKeyword = 139,
NamespaceKeyword = 140,
NeverKeyword = 141,
ReadonlyKeyword = 142,
RequireKeyword = 143,
NumberKeyword = 144,
ObjectKeyword = 145,
SetKeyword = 146,
StringKeyword = 147,
SymbolKeyword = 148,
TypeKeyword = 149,
UndefinedKeyword = 150,
UniqueKeyword = 151,
UnknownKeyword = 152,
FromKeyword = 153,
GlobalKeyword = 154,
BigIntKeyword = 155,
OverrideKeyword = 156,
OfKeyword = 157,
QualifiedName = 158,
ComputedPropertyName = 159,
TypeParameter = 160,
Parameter = 161,
Decorator = 162,
PropertySignature = 163,
PropertyDeclaration = 164,
MethodSignature = 165,
MethodDeclaration = 166,
Constructor = 167,
GetAccessor = 168,
SetAccessor = 169,
CallSignature = 170,
ConstructSignature = 171,
IndexSignature = 172,
TypePredicate = 173,
TypeReference = 174,
FunctionType = 175,
ConstructorType = 176,
TypeQuery = 177,
TypeLiteral = 178,
ArrayType = 179,
TupleType = 180,
OptionalType = 181,
RestType = 182,
UnionType = 183,
IntersectionType = 184,
ConditionalType = 185,
InferType = 186,
ParenthesizedType = 187,
ThisType = 188,
TypeOperator = 189,
IndexedAccessType = 190,
MappedType = 191,
LiteralType = 192,
NamedTupleMember = 193,
TemplateLiteralType = 194,
TemplateLiteralTypeSpan = 195,
ImportType = 196,
ObjectBindingPattern = 197,
ArrayBindingPattern = 198,
BindingElement = 199,
ArrayLiteralExpression = 200,
ObjectLiteralExpression = 201,
PropertyAccessExpression = 202,
ElementAccessExpression = 203,
CallExpression = 204,
NewExpression = 205,
TaggedTemplateExpression = 206,
TypeAssertionExpression = 207,
ParenthesizedExpression = 208,
FunctionExpression = 209,
ArrowFunction = 210,
DeleteExpression = 211,
TypeOfExpression = 212,
VoidExpression = 213,
AwaitExpression = 214,
PrefixUnaryExpression = 215,
PostfixUnaryExpression = 216,
BinaryExpression = 217,
ConditionalExpression = 218,
TemplateExpression = 219,
YieldExpression = 220,
SpreadElement = 221,
ClassExpression = 222,
OmittedExpression = 223,
ExpressionWithTypeArguments = 224,
AsExpression = 225,
NonNullExpression = 226,
MetaProperty = 227,
SyntheticExpression = 228,
TemplateSpan = 229,
SemicolonClassElement = 230,
Block = 231,
EmptyStatement = 232,
VariableStatement = 233,
ExpressionStatement = 234,
IfStatement = 235,
DoStatement = 236,
WhileStatement = 237,
ForStatement = 238,
ForInStatement = 239,
ForOfStatement = 240,
ContinueStatement = 241,
BreakStatement = 242,
ReturnStatement = 243,
WithStatement = 244,
SwitchStatement = 245,
LabeledStatement = 246,
ThrowStatement = 247,
TryStatement = 248,
DebuggerStatement = 249,
VariableDeclaration = 250,
VariableDeclarationList = 251,
FunctionDeclaration = 252,
ClassDeclaration = 253,
InterfaceDeclaration = 254,
TypeAliasDeclaration = 255,
EnumDeclaration = 256,
ModuleDeclaration = 257,
ModuleBlock = 258,
CaseBlock = 259,
NamespaceExportDeclaration = 260,
ImportEqualsDeclaration = 261,
ImportDeclaration = 262,
ImportClause = 263,
NamespaceImport = 264,
NamedImports = 265,
ImportSpecifier = 266,
ExportAssignment = 267,
ExportDeclaration = 268,
NamedExports = 269,
NamespaceExport = 270,
ExportSpecifier = 271,
MissingDeclaration = 272,
ExternalModuleReference = 273,
JsxElement = 274,
JsxSelfClosingElement = 275,
JsxOpeningElement = 276,
JsxClosingElement = 277,
JsxFragment = 278,
JsxOpeningFragment = 279,
JsxClosingFragment = 280,
JsxAttribute = 281,
JsxAttributes = 282,
JsxSpreadAttribute = 283,
JsxExpression = 284,
CaseClause = 285,
DefaultClause = 286,
HeritageClause = 287,
CatchClause = 288,
PropertyAssignment = 289,
ShorthandPropertyAssignment = 290,
SpreadAssignment = 291,
EnumMember = 292,
UnparsedPrologue = 293,
UnparsedPrepend = 294,
UnparsedText = 295,
UnparsedInternalText = 296,
UnparsedSyntheticReference = 297,
SourceFile = 298,
Bundle = 299,
UnparsedSource = 300,
InputFiles = 301,
JSDocTypeExpression = 302,
JSDocNameReference = 303,
JSDocAllType = 304,
JSDocUnknownType = 305,
JSDocNullableType = 306,
JSDocNonNullableType = 307,
JSDocOptionalType = 308,
JSDocFunctionType = 309,
JSDocVariadicType = 310,
JSDocNamepathType = 311,
JSDocComment = 312,
JSDocText = 313,
JSDocTypeLiteral = 314,
JSDocSignature = 315,
JSDocLink = 316,
JSDocTag = 317,
JSDocAugmentsTag = 318,
JSDocImplementsTag = 319,
JSDocAuthorTag = 320,
JSDocDeprecatedTag = 321,
JSDocClassTag = 322,
JSDocPublicTag = 323,
JSDocPrivateTag = 324,
JSDocProtectedTag = 325,
JSDocReadonlyTag = 326,
JSDocOverrideTag = 327,
JSDocCallbackTag = 328,
JSDocEnumTag = 329,
JSDocParameterTag = 330,
JSDocReturnTag = 331,
JSDocThisTag = 332,
JSDocTypeTag = 333,
JSDocTemplateTag = 334,
JSDocTypedefTag = 335,
JSDocSeeTag = 336,
JSDocPropertyTag = 337,
SyntaxList = 338,
NotEmittedStatement = 339,
PartiallyEmittedExpression = 340,
CommaListExpression = 341,
MergeDeclarationMarker = 342,
EndOfDeclarationMarker = 343,
SyntheticReferenceExpression = 344,
Count = 345,
FirstAssignment = 62,
LastAssignment = 77,
FirstCompoundAssignment = 63,
LastCompoundAssignment = 77,
FirstReservedWord = 80,
LastReservedWord = 115,
FirstKeyword = 80,
LastKeyword = 157,
FirstFutureReservedWord = 116,
LastFutureReservedWord = 124,
FirstTypeNode = 173,
LastTypeNode = 196,
FirstPunctuation = 18,
LastPunctuation = 77,
FirstToken = 0,
LastToken = 157,
FirstTriviaToken = 2,
LastTriviaToken = 7,
FirstLiteralToken = 8,
LastLiteralToken = 14,
FirstTemplateToken = 14,
LastTemplateToken = 17,
FirstBinaryOperator = 29,
LastBinaryOperator = 77,
FirstStatement = 233,
LastStatement = 249,
FirstNode = 158,
FirstJSDocNode = 302,
LastJSDocNode = 337,
FirstJSDocTagNode = 317,
LastJSDocTagNode = 337,
}
export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia;
export type LiteralSyntaxKind = SyntaxKind.NumericLiteral | SyntaxKind.BigIntLiteral | SyntaxKind.StringLiteral | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.RegularExpressionLiteral | SyntaxKind.NoSubstitutionTemplateLiteral;
export type PseudoLiteralSyntaxKind = SyntaxKind.TemplateHead | SyntaxKind.TemplateMiddle | SyntaxKind.TemplateTail;
export type PunctuationSyntaxKind = SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.DotToken | SyntaxKind.DotDotDotToken | SyntaxKind.SemicolonToken | SyntaxKind.CommaToken | SyntaxKind.QuestionDotToken | SyntaxKind.LessThanToken | SyntaxKind.LessThanSlashToken | SyntaxKind.GreaterThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.EqualsEqualsToken | SyntaxKind.ExclamationEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.EqualsGreaterThanToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.AsteriskToken | SyntaxKind.AsteriskAsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken | SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken | SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken | SyntaxKind.ExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.BacktickToken | SyntaxKind.EqualsToken | SyntaxKind.PlusEqualsToken | SyntaxKind.MinusEqualsToken | SyntaxKind.AsteriskEqualsToken | SyntaxKind.AsteriskAsteriskEqualsToken | SyntaxKind.SlashEqualsToken | SyntaxKind.PercentEqualsToken | SyntaxKind.LessThanLessThanEqualsToken | SyntaxKind.GreaterThanGreaterThanEqualsToken | SyntaxKind.GreaterThanGreaterThanGreaterThanEqualsToken | SyntaxKind.AmpersandEqualsToken | SyntaxKind.BarEqualsToken | SyntaxKind.CaretEqualsToken;
export type KeywordSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AnyKeyword | SyntaxKind.AsKeyword | SyntaxKind.AssertsKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.AwaitKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.BreakKeyword | SyntaxKind.CaseKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClassKeyword | SyntaxKind.ConstKeyword | SyntaxKind.ConstructorKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DebuggerKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.DeleteKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.EnumKeyword | SyntaxKind.ExportKeyword | SyntaxKind.ExtendsKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FinallyKeyword | SyntaxKind.ForKeyword | SyntaxKind.FromKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.GetKeyword | SyntaxKind.GlobalKeyword | SyntaxKind.IfKeyword | SyntaxKind.ImplementsKeyword | SyntaxKind.ImportKeyword | SyntaxKind.InferKeyword | SyntaxKind.InKeyword | SyntaxKind.InstanceOfKeyword | SyntaxKind.InterfaceKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.IsKeyword | SyntaxKind.KeyOfKeyword | SyntaxKind.LetKeyword | SyntaxKind.ModuleKeyword | SyntaxKind.NamespaceKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.OfKeyword | SyntaxKind.PackageKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.RequireKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SetKeyword | SyntaxKind.StaticKeyword | SyntaxKind.StringKeyword | SyntaxKind.SuperKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.ThisKeyword | SyntaxKind.ThrowKeyword | SyntaxKind.TrueKeyword | SyntaxKind.TryKeyword | SyntaxKind.TypeKeyword | SyntaxKind.TypeOfKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VarKeyword | SyntaxKind.VoidKeyword | SyntaxKind.WhileKeyword | SyntaxKind.WithKeyword | SyntaxKind.YieldKeyword;
export type ModifierSyntaxKind = SyntaxKind.AbstractKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.ConstKeyword | SyntaxKind.DeclareKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.ExportKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.ReadonlyKeyword | SyntaxKind.OverrideKeyword | SyntaxKind.StaticKeyword;
export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.BigIntKeyword | SyntaxKind.BooleanKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.NeverKeyword | SyntaxKind.NumberKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.VoidKeyword;
export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PseudoLiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind;
export type JsxTokenSyntaxKind = SyntaxKind.LessThanSlashToken | SyntaxKind.EndOfFileToken | SyntaxKind.ConflictMarkerTrivia | SyntaxKind.JsxText | SyntaxKind.JsxTextAllWhiteSpaces | SyntaxKind.OpenBraceToken | SyntaxKind.LessThanToken;
export type JSDocSyntaxKind = SyntaxKind.EndOfFileToken | SyntaxKind.WhitespaceTrivia | SyntaxKind.AtToken | SyntaxKind.NewLineTrivia | SyntaxKind.AsteriskToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.LessThanToken | SyntaxKind.GreaterThanToken | SyntaxKind.OpenBracketToken | SyntaxKind.CloseBracketToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.Unknown | KeywordSyntaxKind;
export enum NodeFlags {
None = 0,
Let = 1,
Const = 2,
NestedNamespace = 4,
Synthesized = 8,
Namespace = 16,
OptionalChain = 32,
ExportContext = 64,
ContainsThis = 128,
HasImplicitReturn = 256,
HasExplicitReturn = 512,
GlobalAugmentation = 1024,
HasAsyncFunctions = 2048,
DisallowInContext = 4096,
YieldContext = 8192,
DecoratorContext = 16384,
AwaitContext = 32768,
ThisNodeHasError = 65536,
JavaScriptFile = 131072,
ThisNodeOrAnySubNodesHasError = 262144,
HasAggregatedChildData = 524288,
JSDoc = 4194304,
JsonFile = 33554432,
BlockScoped = 3,
ReachabilityCheckFlags = 768,
ReachabilityAndEmitFlags = 2816,
ContextFlags = 25358336,
TypeExcludesFlags = 40960,
}
export 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,
HasComputedJSDocModifiers = 4096,
Deprecated = 8192,
Override = 16384,
HasComputedFlags = 536870912,
AccessibilityModifier = 28,
ParameterPropertyModifier = 16476,
NonPublicAccessibilityModifier = 24,
TypeScriptModifier = 18654,
ExportDefault = 513,
All = 27647
}
export 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
}
export interface Node extends ReadonlyTextRange {
readonly kind: SyntaxKind;
readonly flags: NodeFlags;
readonly decorators?: NodeArray<Decorator>;
readonly modifiers?: ModifiersArray;
readonly parent: Node;
}
export interface JSDocContainer {
}
export type HasJSDoc = ParameterDeclaration | CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | PropertySignature | ArrowFunction | ParenthesizedExpression | SpreadAssignment | ShorthandPropertyAssignment | PropertyAssignment | FunctionExpression | EmptyStatement | DebuggerStatement | Block | VariableStatement | ExpressionStatement | IfStatement | DoStatement | WhileStatement | ForStatement | ForInStatement | ForOfStatement | BreakStatement | ContinueStatement | ReturnStatement | WithStatement | SwitchStatement | LabeledStatement | ThrowStatement | TryStatement | FunctionDeclaration | ConstructorDeclaration | MethodDeclaration | VariableDeclaration | PropertyDeclaration | AccessorDeclaration | ClassLikeDeclaration | InterfaceDeclaration | TypeAliasDeclaration | EnumMember | EnumDeclaration | ModuleDeclaration | ImportEqualsDeclaration | ImportDeclaration | NamespaceExportDeclaration | ExportAssignment | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | ExportDeclaration | NamedTupleMember | EndOfFileToken;
export type HasType = SignatureDeclaration | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | TypePredicateNode | ParenthesizedTypeNode | TypeOperatorNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocNonNullableType | JSDocNullableType | JSDocOptionalType | JSDocVariadicType;
export type HasTypeArguments = CallExpression | NewExpression | TaggedTemplateExpression | JsxOpeningElement | JsxSelfClosingElement;
export type HasInitializer = HasExpressionInitializer | ForStatement | ForInStatement | ForOfStatement | JsxAttribute;
export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertySignature | PropertyDeclaration | PropertyAssignment | EnumMember;
export interface NodeArray<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {
hasTrailingComma?: boolean;
}
export interface Token<TKind extends SyntaxKind> extends Node {
readonly kind: TKind;
}
export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & JSDocContainer;
export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {
}
export type DotToken = PunctuationToken<SyntaxKind.DotToken>;
export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;
export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;
export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;
export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>;
export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>;
export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>;
export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>;
export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>;
export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>;
export type QuestionDotToken = PunctuationToken<SyntaxKind.QuestionDotToken>;
export interface KeywordToken<TKind extends KeywordSyntaxKind> extends Token<TKind> {
}
export type AssertsKeyword = KeywordToken<SyntaxKind.AssertsKeyword>;
export type AwaitKeyword = KeywordToken<SyntaxKind.AwaitKeyword>;
/** @deprecated Use `AwaitKeyword` instead. */
export type AwaitKeywordToken = AwaitKeyword;
/** @deprecated Use `AssertsKeyword` instead. */
export type AssertsToken = AssertsKeyword;
export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> {
}
export type AbstractKeyword = ModifierToken<SyntaxKind.AbstractKeyword>;
export type AsyncKeyword = ModifierToken<SyntaxKind.AsyncKeyword>;
export type ConstKeyword = ModifierToken<SyntaxKind.ConstKeyword>;
export type DeclareKeyword = ModifierToken<SyntaxKind.DeclareKeyword>;
export type DefaultKeyword = ModifierToken<SyntaxKind.DefaultKeyword>;
export type ExportKeyword = ModifierToken<SyntaxKind.ExportKeyword>;
export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>;
export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>;
export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>;
export type ReadonlyKeyword = ModifierToken<SyntaxKind.ReadonlyKeyword>;
export type OverrideKeyword = ModifierToken<SyntaxKind.OverrideKeyword>;
export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;
/** @deprecated Use `ReadonlyKeyword` instead. */
export type ReadonlyToken = ReadonlyKeyword;
export type Modifier = AbstractKeyword | AsyncKeyword | ConstKeyword | DeclareKeyword | DefaultKeyword | ExportKeyword | PrivateKeyword | ProtectedKeyword | PublicKeyword | OverrideKeyword | ReadonlyKeyword | StaticKeyword;
export type AccessibilityModifier = PublicKeyword | PrivateKeyword | ProtectedKeyword;
export type ParameterPropertyModifier = AccessibilityModifier | ReadonlyKeyword;
export type ClassMemberModifier = AccessibilityModifier | ReadonlyKeyword | StaticKeyword;
export type ModifiersArray = NodeArray<Modifier>;
export enum GeneratedIdentifierFlags {
None = 0,
ReservedInNestedScopes = 8,
Optimistic = 16,
FileLevel = 32,
AllowNameSubstitution = 64
}
export interface Identifier extends PrimaryExpression, Declaration {
readonly 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.
*/
readonly escapedText: __String;
readonly originalKeywordKind?: SyntaxKind;
isInJSDocNamespace?: boolean;
}
export interface TransientIdentifier extends Identifier {
resolvedSymbol: Symbol;
}
export interface QualifiedName extends Node {
readonly kind: SyntaxKind.QualifiedName;
readonly left: EntityName;
readonly right: Identifier;
}
export type EntityName = Identifier | QualifiedName;
export type PropertyName = Identifier | StringLiteral | NumericLiteral | ComputedPropertyName | PrivateIdentifier;
export type MemberName = Identifier | PrivateIdentifier;
export type DeclarationName = Identifier | PrivateIdentifier | StringLiteralLike | NumericLiteral | ComputedPropertyName | ElementAccessExpression | BindingPattern | EntityNameExpression;
export interface Declaration extends Node {
_declarationBrand: any;
}
export interface NamedDeclaration extends Declaration {
readonly name?: DeclarationName;
}
export interface DeclarationStatement extends NamedDeclaration, Statement {
readonly name?: Identifier | StringLiteral | NumericLiteral;
}
export interface ComputedPropertyName extends Node {
readonly kind: SyntaxKind.ComputedPropertyName;
readonly parent: Declaration;
readonly expression: Expression;
}
export interface PrivateIdentifier extends Node {
readonly kind: SyntaxKind.PrivateIdentifier;
readonly escapedText: __String;
}
export interface Decorator extends Node {
readonly kind: SyntaxKind.Decorator;
readonly parent: NamedDeclaration;
readonly expression: LeftHandSideExpression;
}
export interface TypeParameterDeclaration extends NamedDeclaration {
readonly kind: SyntaxKind.TypeParameter;
readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode;
readonly name: Identifier;
/** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */
readonly constraint?: TypeNode;
readonly default?: TypeNode;
expression?: Expression;
}
export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer {
readonly kind: SignatureDeclaration["kind"];
readonly name?: PropertyName;
readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
readonly parameters: NodeArray<ParameterDeclaration>;
readonly type?: TypeNode;
}
export type SignatureDeclaration = CallSignatureDeclaration | ConstructSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | ConstructorTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | ConstructorDeclaration | AccessorDeclaration | FunctionExpression | ArrowFunction;
export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
readonly kind: SyntaxKind.CallSignature;
}
export interface ConstructSignatureDeclaration extends SignatureDeclarationBase, TypeElement {
readonly kind: SyntaxKind.ConstructSignature;
}
export type BindingName = Identifier | BindingPattern;
export interface VariableDeclaration extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.VariableDeclaration;
readonly parent: VariableDeclarationList | CatchClause;
readonly name: BindingName;
readonly exclamationToken?: ExclamationToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
export interface VariableDeclarationList extends Node {
readonly kind: SyntaxKind.VariableDeclarationList;
readonly parent: VariableStatement | ForStatement | ForOfStatement | ForInStatement;
readonly declarations: NodeArray<VariableDeclaration>;
}
export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer {
readonly kind: SyntaxKind.Parameter;
readonly parent: SignatureDeclaration;
readonly dotDotDotToken?: DotDotDotToken;
readonly name: BindingName;
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
export interface BindingElement extends NamedDeclaration {
readonly kind: SyntaxKind.BindingElement;
readonly parent: BindingPattern;
readonly propertyName?: PropertyName;
readonly dotDotDotToken?: DotDotDotToken;
readonly name: BindingName;
readonly initializer?: Expression;
}
export interface PropertySignature extends TypeElement, JSDocContainer {
readonly kind: SyntaxKind.PropertySignature;
readonly name: PropertyName;
readonly questionToken?: QuestionToken;
readonly type?: TypeNode;
initializer?: Expression;
}
export interface PropertyDeclaration extends ClassElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyDeclaration;
readonly parent: ClassLikeDeclaration;
readonly name: PropertyName;
readonly questionToken?: QuestionToken;
readonly exclamationToken?: ExclamationToken;
readonly type?: TypeNode;
readonly initializer?: Expression;
}
export interface ObjectLiteralElement extends NamedDeclaration {
_objectLiteralBrand: any;
readonly name?: PropertyName;
}
/** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */
export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | SpreadAssignment | MethodDeclaration | AccessorDeclaration;
export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.PropertyAssignment;
readonly parent: ObjectLiteralExpression;
readonly name: PropertyName;
readonly questionToken?: QuestionToken;
readonly exclamationToken?: ExclamationToken;
readonly initializer: Expression;
}
export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.ShorthandPropertyAssignment;
readonly parent: ObjectLiteralExpression;
readonly name: Identifier;
readonly questionToken?: QuestionToken;
readonly exclamationToken?: ExclamationToken;
readonly equalsToken?: EqualsToken;
readonly objectAssignmentInitializer?: Expression;
}
export interface SpreadAssignment extends ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.SpreadAssignment;
readonly parent: ObjectLiteralExpression;
readonly expression: Expression;
}
export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | PropertySignature | JsxAttribute | ShorthandPropertyAssignment | EnumMember | JSDocPropertyTag | JSDocParameterTag;
export interface PropertyLikeDeclaration extends NamedDeclaration {
readonly name: PropertyName;
}
export interface ObjectBindingPattern extends Node {
readonly kind: SyntaxKind.ObjectBindingPattern;
readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
readonly elements: NodeArray<BindingElement>;
}
export interface ArrayBindingPattern extends Node {
readonly kind: SyntaxKind.ArrayBindingPattern;
readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement;
readonly elements: NodeArray<ArrayBindingElement>;
}
export type BindingPattern = ObjectBindingPattern | ArrayBindingPattern;
export type ArrayBindingElement = BindingElement | OmittedExpression;
/**
* Several node kinds share function-like features such as a signature,
* a name, and a body. These nodes should extend FunctionLikeDeclarationBase.
* Examples:
* - FunctionDeclaration
* - MethodDeclaration
* - AccessorDeclaration
*/
export interface FunctionLikeDeclarationBase extends SignatureDeclarationBase {
_functionLikeDeclarationBrand: any;
readonly asteriskToken?: AsteriskToken;
readonly questionToken?: QuestionToken;
readonly exclamationToken?: ExclamationToken;
readonly body?: Block | Expression;
}
export type FunctionLikeDeclaration = FunctionDeclaration | MethodDeclaration | GetAccessorDeclaration | SetAccessorDeclaration | ConstructorDeclaration | FunctionExpression | ArrowFunction;
/** @deprecated Use SignatureDeclaration */
export type FunctionLike = SignatureDeclaration;
export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement {
readonly kind: SyntaxKind.FunctionDeclaration;
readonly name?: Identifier;
readonly body?: FunctionBody;
}
export interface MethodSignature extends SignatureDeclarationBase, TypeElement {
readonly kind: SyntaxKind.MethodSignature;
readonly parent: ObjectTypeDeclaration;
readonly name: PropertyName;
}
export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.MethodDeclaration;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression;
readonly name: PropertyName;
readonly body?: FunctionBody;
}
export interface ConstructorDeclaration extends FunctionLikeDeclarationBase, ClassElement, JSDocContainer {
readonly kind: SyntaxKind.Constructor;
readonly parent: ClassLikeDeclaration;
readonly body?: FunctionBody;
}
/** For when we encounter a semicolon in a class declaration. ES6 allows these as class elements. */
export interface SemicolonClassElement extends ClassElement {
readonly kind: SyntaxKind.SemicolonClassElement;
readonly parent: ClassLikeDeclaration;
}
export interface GetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.GetAccessor;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
readonly name: PropertyName;
readonly body?: FunctionBody;
}
export interface SetAccessorDeclaration extends FunctionLikeDeclarationBase, ClassElement, TypeElement, ObjectLiteralElement, JSDocContainer {
readonly kind: SyntaxKind.SetAccessor;
readonly parent: ClassLikeDeclaration | ObjectLiteralExpression | TypeLiteralNode | InterfaceDeclaration;
readonly name: PropertyName;
readonly body?: FunctionBody;
}
export type AccessorDeclaration = GetAccessorDeclaration | SetAccessorDeclaration;
export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement {
readonly kind: SyntaxKind.IndexSignature;
readonly parent: ObjectTypeDeclaration;
readonly type: TypeNode;
}
export interface TypeNode extends Node {
_typeNodeBrand: any;
}
export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode {
readonly kind: TKind;
}
export interface ImportTypeNode extends NodeWithTypeArguments {
readonly kind: SyntaxKind.ImportType;
readonly isTypeOf: boolean;
readonly argument: TypeNode;
readonly qualifier?: EntityName;
}
export interface ThisTypeNode extends TypeNode {
readonly kind: SyntaxKind.ThisType;
}
export type FunctionOrConstructorTypeNode = FunctionTypeNode | ConstructorTypeNode;
export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase {
readonly kind: SyntaxKind.FunctionType | SyntaxKind.ConstructorType;
readonly type: TypeNode;
}
export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase {
readonly kind: SyntaxKind.FunctionType;
}
export interface ConstructorTypeNode extends FunctionOrConstructorTypeNodeBase {
readonly kind: SyntaxKind.ConstructorType;
}
export interface NodeWithTypeArguments extends TypeNode {
readonly typeArguments?: NodeArray<TypeNode>;
}
export type TypeReferenceType = TypeReferenceNode | ExpressionWithTypeArguments;
export interface TypeReferenceNode extends NodeWithTypeArguments {
readonly kind: SyntaxKind.TypeReference;
readonly typeName: EntityName;
}
export interface TypePredicateNode extends TypeNode {
readonly kind: SyntaxKind.TypePredicate;
readonly parent: SignatureDeclaration | JSDocTypeExpression;
readonly assertsModifier?: AssertsToken;
readonly parameterName: Identifier | ThisTypeNode;
readonly type?: TypeNode;
}
export interface TypeQueryNode extends TypeNode {
readonly kind: SyntaxKind.TypeQuery;
readonly exprName: EntityName;
}
export interface TypeLiteralNode extends TypeNode, Declaration {
readonly kind: SyntaxKind.TypeLiteral;
readonly members: NodeArray<TypeElement>;
}
export interface ArrayTypeNode extends TypeNode {
readonly kind: SyntaxKind.ArrayType;
readonly elementType: TypeNode;
}
export interface TupleTypeNode extends TypeNode {
readonly kind: SyntaxKind.TupleType;
readonly elements: NodeArray<TypeNode | NamedTupleMember>;
}
export interface NamedTupleMember extends TypeNode, JSDocContainer, Declaration {
readonly kind: SyntaxKind.NamedTupleMember;
readonly dotDotDotToken?: Token<SyntaxKind.DotDotDotToken>;
readonly name: Identifier;
readonly questionToken?: Token<SyntaxKind.QuestionToken>;
readonly type: TypeNode;
}
export interface OptionalTypeNode extends TypeNode {
readonly kind: SyntaxKind.OptionalType;
readonly type: TypeNode;
}
export interface RestTypeNode extends TypeNode {
readonly kind: SyntaxKind.RestType;
readonly type: TypeNode;
}
export type UnionOrIntersectionTypeNode = UnionTypeNode | IntersectionTypeNode;
export interface UnionTypeNode extends TypeNode {
readonly kind: SyntaxKind.UnionType;
readonly types: NodeArray<TypeNode>;
}
export interface IntersectionTypeNode extends TypeNode {
readonly kind: SyntaxKind.IntersectionType;
readonly types: NodeArray<TypeNode>;
}
export interface ConditionalTypeNode extends TypeNode {
readonly kind: SyntaxKind.ConditionalType;
readonly checkType: TypeNode;
readonly extendsType: TypeNode;
readonly trueType: TypeNode;
readonly falseType: TypeNode;
}
export interface InferTypeNode extends TypeNode {
readonly kind: SyntaxKind.InferType;
readonly typeParameter: TypeParameterDeclaration;
}
export interface ParenthesizedTypeNode extends TypeNode {
readonly kind: SyntaxKind.ParenthesizedType;
readonly type: TypeNode;
}
export interface TypeOperatorNode extends TypeNode {
readonly kind: SyntaxKind.TypeOperator;
readonly operator: SyntaxKind.KeyOfKeyword | SyntaxKind.UniqueKeyword | SyntaxKind.ReadonlyKeyword;
readonly type: TypeNode;
}
export interface IndexedAccessTypeNode extends TypeNode {
readonly kind: SyntaxKind.IndexedAccessType;
readonly objectType: TypeNode;
readonly indexType: TypeNode;
}
export interface MappedTypeNode extends TypeNode, Declaration {
readonly kind: SyntaxKind.MappedType;
readonly readonlyToken?: ReadonlyToken | PlusToken | MinusToken;
readonly typeParameter: TypeParameterDeclaration;
readonly nameType?: TypeNode;
readonly questionToken?: QuestionToken | PlusToken | MinusToken;
readonly type?: TypeNode;
}
export interface LiteralTypeNode extends TypeNode {
readonly kind: SyntaxKind.LiteralType;
readonly literal: NullLiteral | BooleanLiteral | LiteralExpression | PrefixUnaryExpression;
}
export interface StringLiteral extends LiteralExpression, Declaration {
readonly kind: SyntaxKind.StringLiteral;
}
export type StringLiteralLike = StringLiteral | NoSubstitutionTemplateLiteral;
export type PropertyNameLiteral = Identifier | StringLiteralLike | NumericLiteral;
export interface TemplateLiteralTypeNode extends TypeNode {
kind: SyntaxKind.TemplateLiteralType;
readonly head: TemplateHead;
readonly templateSpans: NodeArray<TemplateLiteralTypeSpan>;
}
export interface TemplateLiteralTypeSpan extends TypeNode {
readonly kind: SyntaxKind.TemplateLiteralTypeSpan;
readonly parent: TemplateLiteralTypeNode;
readonly type: TypeNode;
readonly literal: TemplateMiddle | TemplateTail;
}
export interface Expression extends Node {
_expressionBrand: any;
}
export interface OmittedExpression extends Expression {
readonly kind: SyntaxKind.OmittedExpression;
}
export interface PartiallyEmittedExpression extends LeftHandSideExpression {
readonly kind: SyntaxKind.PartiallyEmittedExpression;
readonly expression: Expression;
}
export interface UnaryExpression extends Expression {
_unaryExpressionBrand: any;
}
/** Deprecated, please use UpdateExpression */
export type IncrementExpression = UpdateExpression;
export interface UpdateExpression extends UnaryExpression {
_updateExpressionBrand: any;
}
export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken;
export interface PrefixUnaryExpression extends UpdateExpression {
readonly kind: SyntaxKind.PrefixUnaryExpression;
readonly operator: PrefixUnaryOperator;
readonly operand: UnaryExpression;
}
export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken;
export interface PostfixUnaryExpression extends UpdateExpression {
readonly kind: SyntaxKind.PostfixUnaryExpression;
readonly operand: LeftHandSideExpression;
readonly operator: PostfixUnaryOperator;
}
export interface LeftHandSideExpression extends UpdateExpression {
_leftHandSideExpressionBrand: any;
}
export interface MemberExpression extends LeftHandSideExpression {
_memberExpressionBrand: any;
}
export interface PrimaryExpression extends MemberExpression {
_primaryExpressionBrand: any;
}
export interface NullLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.NullKeyword;
}
export interface TrueLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.TrueKeyword;
}
export interface FalseLiteral extends PrimaryExpression {
readonly kind: SyntaxKind.FalseKeyword;
}
export type BooleanLiteral = TrueLiteral | FalseLiteral;
export interface ThisExpression extends PrimaryExpression {
readonly kind: SyntaxKind.ThisKeyword;
}
export interface SuperExpression extends PrimaryExpression {
readonly kind: SyntaxKind.SuperKeyword;
}
export interface ImportExpression extends PrimaryExpression {
readonly kind: SyntaxKind.ImportKeyword;
}
export interface DeleteExpression extends UnaryExpression {
readonly kind: SyntaxKind.DeleteExpression;
readonly expression: UnaryExpression;
}
export interface TypeOfExpression extends UnaryExpression {
readonly kind: SyntaxKind.TypeOfExpression;
readonly expression: UnaryExpression;
}
export interface VoidExpression extends UnaryExpression {
readonly kind: SyntaxKind.VoidExpression;
readonly expression: UnaryExpression;
}
export interface AwaitExpression extends UnaryExpression {
readonly kind: SyntaxKind.AwaitExpression;
readonly expression: UnaryExpression;
}
export interface YieldExpression extends Expression {
readonly kind: SyntaxKind.YieldExpression;
readonly asteriskToken?: Asteris