import { CreateSourceFileOptions, MapLike, ModuleResolutionCache, Mutable } from "./_namespaces/lpc.js"; export type NodeId = number; export type SymbolId = number; export type Path = string & { __pathBrand: any; }; /** SymbolTable based on ES6 Map interface. */ export type SymbolTable = Map; export interface TextRange { pos: number; end: number; } export interface ReadonlyTextRange { readonly pos: number; readonly end: number; } export interface MacroIncludedFileRange { posInOrigin?: number; endInOrigin?: number; originFilename?: string; } /** Base Node */ export interface Node extends ReadonlyTextRange { readonly kind: SyntaxKind; readonly flags: NodeFlags; readonly parent: Node; } export interface EmitNode { flags: EmitFlags; internalFlags: InternalEmitFlags; annotatedNodes?: Node[]; leadingComments?: SynthesizedComment[]; trailingComments?: SynthesizedComment[]; commentRange?: TextRange; constantValue?: string | number; externalHelpersModuleName?: Identifier; externalHelpers?: boolean; helpers?: EmitHelper[]; startsOnNewLine?: boolean; snippetElement?: SnippetElement; typeNode?: TypeNode; classThis?: Identifier; assignedName?: Expression; identifierTypeArguments?: NodeArray; autoGenerate: AutoGenerateInfo | undefined; } export interface TypeChecker { getTypeOfSymbol(symbol: Symbol): Type; createSymbol(flags: SymbolFlags, name: string, checkFlags?: CheckFlags): TransientSymbol; getDeclaredTypeOfSymbol(symbol: Symbol): Type; getStringType(): Type; signatureToString(signature: Signature, enclosingDeclaration?: Node, flags?: TypeFormatFlags, kind?: SignatureKind): string; symbolToString(symbol: Symbol, enclosingDeclaration?: Node, meaning?: SymbolFlags, flags?: SymbolFormatFlags): string; getSignatureFromDeclaration(declaration: SignatureDeclaration): Signature | undefined; /** Follow all aliases to get the original symbol. */ getAliasedSymbol(symbol: Symbol): Symbol; getSymbolAtLocation(node: Node): Symbol | undefined; getTypeOfSymbolAtLocation(symbol: Symbol, node: Node): Type; getRootSymbols(symbol: Symbol): readonly Symbol[]; evaluate(expr: Expression, location?: Declaration): EvaluatorResult; /** * True if this type is assignable to `ReadonlyArray`. */ isArrayLikeType(type: Type): boolean; /** Note that the resulting nodes cannot be checked. */ typeToTypeNode(type: Type, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeNode | undefined; getReturnTypeOfSignature(signature: Signature): Type; resolveName(name: string, location: Node | undefined, meaning: SymbolFlags, excludeGlobals: boolean): Symbol | undefined; resolveBaseTypesOfClass(type: InterfaceType): Type[]; isArgumentsSymbol(symbol: Symbol): boolean; /** * returns unknownSignature in the case of an error. * returns undefined if the node is not valid. * @param argumentCount Apparent number of arguments, passed in case of a possibly incomplete call. This should come from an ArgumentListInfo. See `signatureHelp.ts`. */ getResolvedSignature(node: CallLikeExpression, candidatesOutArray?: Signature[], argumentCount?: number): Signature | undefined; /** * The function returns the value (local variable) symbol of an identifier in the short-hand property assignment. * This is necessary as an identifier in short-hand property assignment can contains two meaning: property name and property value. */ getShorthandAssignmentValueSymbol(location: Node | undefined): Symbol | undefined; isUnknownSymbol(symbol: Symbol): boolean; isUndefinedSymbol(symbol: Symbol): boolean; getMergedSymbol(symbol: Symbol): Symbol; getTypeAtLocation(node: Node): Type; getSymbolsInScope(location: Node, meaning: SymbolFlags): Symbol[]; /** * Depending on the operation performed, it may be appropriate to throw away the checker * if the cancellation token is triggered. Typically, if it is used for error checking * and the operation is cancelled, then it should be discarded, otherwise it is safe to keep. */ runWithCancellationToken(token: CancellationToken, cb: (checker: TypeChecker) => T): T; /** Note that the resulting nodes cannot be checked. */ symbolToTypeParameterDeclarations(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): NodeArray | undefined; getNullableType(type: Type, flags: TypeFlags): Type; getNonNullableType(type: Type): Type; getSignaturesOfType(type: Type, kind: SignatureKind): readonly Signature[]; getIndexTypeOfType(type: Type, kind: IndexKind): Type | undefined; getBaseConstraintOfType(type: Type): Type | undefined; getDefaultFromTypeParameter(type: Type): Type | undefined; getPropertyOfType(type: Type, propertyName: string): Symbol | undefined; getTypeFromTypeNode(node: TypeNode): Type; getFullyQualifiedName(symbol: Symbol): string; getWidenedType(type: Type): Type; getAugmentedPropertiesOfType(type: Type): Symbol[]; getPropertiesOfType(type: Type): Symbol[]; getExportsOfModule(moduleSymbol: Symbol): Symbol[]; getTypePredicateOfSignature(signature: Signature): TypePredicate | undefined; /** Note that the resulting nodes cannot be checked. */ typeParameterToDeclaration(parameter: TypeParameter, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): TypeParameterDeclaration | undefined; /** Note that the resulting nodes cannot be checked. */ symbolToParameterDeclaration(symbol: Symbol, enclosingDeclaration: Node | undefined, flags: NodeBuilderFlags | undefined): ParameterDeclaration | undefined; isOptionalParameter(node: ParameterDeclaration): boolean; } export type CompilerOptionsValue = string | number | boolean | (string | number)[] | string[] | MapLike | MapLike | ProjectReference[] | null | undefined; export interface TypeAcquisition { enable?: boolean; include?: string[]; exclude?: string[]; disableFilenameBasedTypeAcquisition?: boolean; [option: string]: CompilerOptionsValue | undefined; } export interface ProjectReference { /** A normalized path on disk */ path: string; /** The path as the user originally wrote it */ originalPath?: string; /** @deprecated */ prepend?: boolean; /** True if it is intended that this reference form a circularity */ circular?: boolean; } /** Either a parsed command line or a parsed tsconfig.json */ export interface ParsedCommandLine { options: CompilerOptions; typeAcquisition?: TypeAcquisition; fileNames: string[]; projectReferences?: readonly ProjectReference[]; watchOptions?: WatchOptions; raw?: any; errors: Diagnostic[]; wildcardDirectories?: MapLike; compileOnSave?: boolean; } export interface ResolvedProjectReference { commandLine: ParsedCommandLine; sourceFile: SourceFile; references?: readonly (ResolvedProjectReference | undefined)[]; } /** * 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. */ export interface ResolvedModule { /** Path of the file the module was resolved to. */ resolvedFileName: string; /** True if `resolvedFileName` comes from `node_modules`. */ isExternalLibraryImport?: boolean; /** * True if the original module reference used a .ts extension to refer directly to a .ts file, * which should produce an error during checking if emit is enabled. */ resolvedUsingTsExtension?: boolean; } /** * ResolvedModule with an explicitly provided `extension` property. * Prefer this over `ResolvedModule`. * If changing this, remember to change `moduleResolutionIsEqualTo`. */ export 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: string; packageId?: PackageId; } export interface ResolvedTypeReferenceDirective { primary: boolean; resolvedFileName: string | undefined; packageId?: PackageId; /** True if `resolvedFileName` comes from `node_modules`. */ isExternalLibraryImport?: boolean; } export interface ResolvedTypeReferenceDirectiveWithFailedLookupLocations { readonly resolvedTypeReferenceDirective: ResolvedTypeReferenceDirective | undefined; } export interface ResolvedModuleWithFailedLookupLocations { readonly resolvedModule: ResolvedModuleFull | undefined; } export declare const enum SignatureKind { Call = 0, Construct = 1 } export type DestructuringPattern = BindingPattern | ObjectLiteralExpression | ArrayLiteralExpression; export interface Type { flags: TypeFlags; symbol: Symbol; pattern?: DestructuringPattern; aliasSymbol?: Symbol; aliasTypeArguments?: readonly Type[]; } export declare const enum SyntaxKind { Unknown = 0,// fIrst token EndOfFileToken = 1, SingleLineCommentTrivia = 2, MultiLineCommentTrivia = 3, NewLineTrivia = 4, WhitespaceTrivia = 5, ConflictMarkerTrivia = 6, MacroIdentifierTrivia = 7, ShebangTrivia = 8, NonTextFileMarkerTrivia = 9, NumericLiteral = 10, IntLiteral = 11, CharLiteral = 12, FloatLiteral = 13, BytesLiteral = 14, StringArrayLiteral = 15, StringLiteral = 16, OpenBraceToken = 17, BacktickToken = 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, LessThanDotDotToken = 31, GreaterThanToken = 32, LessThanEqualsToken = 33, GreaterThanEqualsToken = 34, EqualsEqualsToken = 35, ExclamationEqualsToken = 36, EqualsEqualsEqualsToken = 37, ExclamationEqualsEqualsToken = 38, EqualsGreaterThanToken = 39, MinusGreaterThanToken = 40, PlusToken = 41, MinusToken = 42, AsteriskToken = 43, AsteriskAsteriskToken = 44, SlashToken = 45, PercentToken = 46, PlusPlusToken = 47, MinusMinusToken = 48, LessThanLessThanToken = 49, GreaterThanGreaterThanToken = 50, GreaterThanGreaterThanGreaterThanToken = 51, AmpersandToken = 52, BarToken = 53, CaretToken = 54, ExclamationToken = 55, DoubleExclamationToken = 56, TildeToken = 57, AmpersandAmpersandToken = 58, BarBarToken = 59, QuestionToken = 60, ColonToken = 61, AtToken = 62, AtAtToken = 63, QuestionQuestionToken = 64, HashToken = 65, OpenParenColonToken = 66,// for inline closures ColonCloseParenToken = 67, OpenParenBracketToken = 68,// for mapping literal OpenParenBraceToken = 69,// for array literal OpenParenAsteriskToken = 70,// (*fn) shortcut for evaluate() ColonColonToken = 71, LambdaToken = 72, DotDotToken = 73, EqualsToken = 74,// first assignment PlusEqualsToken = 75, MinusEqualsToken = 76, AsteriskEqualsToken = 77, AsteriskAsteriskEqualsToken = 78, SlashEqualsToken = 79, PercentEqualsToken = 80, LessThanLessThanEqualsToken = 81, GreaterThanGreaterThanEqualsToken = 82, GreaterThanGreaterThanGreaterThanEqualsToken = 83, AmpersandEqualsToken = 84, BarEqualsToken = 85, BarBarEqualsToken = 86, AmpersandAmpersandEqualsToken = 87, QuestionQuestionEqualsToken = 88, CaretEqualsToken = 89,// last assignment Identifier = 90, StringizedIdentifier = 91, IntKeyword = 93,// FIrst Keyword, FirstReserved Word FloatKeyword = 94, StringKeyword = 95, LwObjectKeyword = 96, AnyKeyword = 97, ClosureKeyword = 98, StructKeyword = 99, CatchKeyword = 100, MixedKeyword = 101, UnknownKeyword = 102, MappingKeyword = 103, VoidKeyword = 104, BreakKeyword = 105, BytesKeyword = 106, DoKeyword = 107, ElseKeyword = 108, ForKeyword = 109, ForEachKeyword = 110, CaseKeyword = 111, DefaultKeyword = 112, IfKeyword = 113, ReturnKeyword = 114, SwitchKeyword = 115, WhileKeyword = 116, AsyncKeyword = 117, InheritKeyword = 118, ContinueKeyword = 119, PrivateKeyword = 120, ProtectedKeyword = 121, PublicKeyword = 122, StaticKeyword = 123, VisibleKeyword = 124, NoSaveKeyword = 125, NoShadowKeyword = 126, IntrinsicKeyword = 127, NoMaskKeyword = 128, VarArgsKeyword = 129, DeprecatedKeyword = 130,// LastReservedWord ClassKeyword = 131, StatusKeyword = 132, UndefinedKeyword = 133, FalseKeyword = 134,// JSON-only TrueKeyword = 135,// JSON-only NullKeyword = 136,// JSON-only NeverKeyword = 137,// typenode only FunctionKeyword = 138,// can be used as a param name SymbolKeyword = 139,// not reserved in fluffos ObjectKeyword = 140,// can occur in a super expr i.e. object::fn() RefKeyword = 141,// fluff only BufferKeyword = 142,// fluff only IsKeyword = 143,// use for type predicates only FunctionsKeyword = 144,// inherit modifier VirtualKeyword = 145,// inherit modifier InKeyword = 146,// not a reserved word in LD (maybe fluff?) NewKeyword = 147,// LastKeyword and LastToken - everything after this will be processed by the binder QualifiedName = 148,// First Node ComputedPropertyName = 149, TypeParameter = 150, Parameter = 151, IndexSignature = 152, CallSignature = 153, PropertyDeclaration = 154, PropertySignature = 155, MethodDeclaration = 156, InterfaceDeclaration = 157, MethodSignature = 158, UnionType = 159,// First Type Node FunctionType = 160, IntersectionType = 161, RestType = 162, ArrayType = 163, MappingType = 164, TupleType = 165, TypeLiteral = 166, TypeQuery = 167, ParenthesizedType = 168, TypeReference = 169, TypePredicate = 170, NamedObjectType = 171, ConditionalType = 172,// Last TYpe Node FunctionDeclaration = 173, ClassDeclaration = 174, ExportSpecifier = 175, ExportDeclaration = 176, MissingDeclaration = 177, PropertyAssignment = 178, ShorthandPropertyAssignment = 179, SourceFile = 180, Bundle = 181, IncludeDirective = 182, DefineDirective = 183, UndefDirective = 184, IfDirective = 185, IfDefDirective = 186, IfNDefDirective = 187, ElseDirective = 188, ElseIfDirective = 189, EndIfDirective = 190, PragmaDirective = 191, JSDocTypeExpression = 192,// First JSDoc Node JSDocNameReference = 193, JSDocMemberName = 194,// C#p JSDocAllType = 195,// The * type JSDocUnknownType = 196,// The ? type JSDocNullableType = 197, JSDocNonNullableType = 198, JSDocOptionalType = 199, JSDocFunctionType = 200, JSDocVariadicType = 201, JSDocNamepathType = 202,// https://jsdoc.app/about-namepaths.html JSDoc = 203, /** @deprecated Use SyntaxKind.JSDoc */ JSDocComment = 203, JSDocText = 204, JSDocTypeLiteral = 205, JSDocSignature = 206, JSDocLink = 207, JSDocLinkCode = 208, JSDocLinkPlain = 209, JSDocTag = 210, JSDocAugmentsTag = 211, JSDocImplementsTag = 212, JSDocAuthorTag = 213, JSDocDeprecatedTag = 214, JSDocClassTag = 215, JSDocPublicTag = 216, JSDocPrivateTag = 217, JSDocProtectedTag = 218, JSDocReadonlyTag = 219, JSDocOverrideTag = 220, JSDocCallbackTag = 221, JSDocOverloadTag = 222, JSDocEnumTag = 223, JSDocParameterTag = 224, JSDocReturnTag = 225, JSDocThisTag = 226, JSDocTypeTag = 227, JSDocTemplateTag = 228, JSDocTypedefTag = 229, JSDocSeeTag = 230, JSDocPropertyTag = 231, JSDocVariableTag = 232, JSDocThrowsTag = 233, JSDocSatisfiesTag = 234, JSDocImportTag = 235,// Last JSDoc Node SyntaxList = 236, NotEmittedStatement = 237, PartiallyEmittedExpression = 238, CommaListExpression = 239, Block = 240, VariableDeclaration = 241, VariableDeclarationList = 242, TypeAliasDeclaration = 243, CaseBlock = 244, StructDeclaration = 245,// WAS: ClassDeclaration, VariableStatement = 246,// FirstStatement ForStatement = 247, ForEachStatement = 248, DoWhileStatement = 249, WhileStatement = 250, ExpressionStatement = 251, ReturnStatement = 252, LabeledStatement = 253, BreakStatement = 254, ContinueStatement = 255, InheritDeclaration = 256, IfStatement = 257, EmptyStatement = 258, CatchStatement = 259, SwitchStatement = 260,// LastStatement LiteralType = 261, StructType = 262, InferType = 263, ThisType = 264, IndexedAccessType = 265, NamedTupleMember = 266, TypeOperator = 267, MappedType = 268, ArrayBindingPattern = 269, BindingElement = 270, ConditionalExpression = 271, CatchExpression = 272, BinaryExpression = 273, FunctionExpression = 274, ArrowFunction = 275, CallExpression = 276, CloneObjectExpression = 277, ClassExpression = 278, SyntheticExpression = 279, NewExpression = 280, NewStructExpression = 281, EvaluateExpression = 282, TypeAssertionExpression = 283, ExpressionWithTypeArguments = 284, ElementAccessExpression = 285, RangeExpression = 286, InlineClosureExpression = 287, LambdaIdentifierExpression = 288, LambdaOperatorExpression = 289, PropertyAccessExpression = 290, SuperAccessExpression = 291, PostfixUnaryExpression = 292, ParenthesizedExpression = 293, ArrayLiteralExpression = 294, MappingLiteralExpression = 295, MappingEntryExpression = 296, ObjectLiteralExpression = 297, SpreadElement = 298, ByRefElement = 299, CastExpression = 300, OmittedExpression = 301, PrefixUnaryExpression = 302, CaseClause = 303, HeritageClause = 304, DefaultClause = 305, Count = 306, FirstReservedWord = 93, LastReservedWord = 130, FirstKeyword = 93, LastKeyword = 147, FirstToken = 0, LastToken = 147, FirstStatement = 246, LastStatement = 260, FirstAssignment = 74, LastAssignment = 89, SuperKeyword = 71, FirstTypeNode = 159, LastTypeNode = 172, FirstNode = 148, FirstFutureReservedWord = 93, LastFutureReservedWord = 147, FirstJSDocNode = 192, LastJSDocNode = 235, FirstLiteralToken = 11, LastLiteralToken = 16, FirstJSDocTagNode = 192, LastJSDocTagNode = 235, FirstTriviaToken = 2, LastTriviaToken = 8, FirstBinaryOperator = 29, LastBinaryOperator = 89, FirstPunctuation = 17, LastPunctuation = 73 } export declare const enum TypeFlags { Any = 1, Unknown = 2, String = 4, Number = 8, Boolean = 16, Enum = 32,// Numeric computed enum member value Float = 64, StringLiteral = 128, IntLiteral = 256, BooleanLiteral = 512, EnumLiteral = 1024,// Always combined with StringLiteral, NumberLiteral, or Union FloatLiteral = 2048, Bytes = 4096, BytesLiteral = 8192,// unique symbol Void = 16384, Undefined = 32768, Null = 65536, Never = 131072,// Never type TypeParameter = 262144,// Type parameter Object = 524288,// Object type Union = 1048576,// Union (T | U) Intersection = 2097152,// Intersection (T & U) Index = 4194304,// keyof T IndexedAccess = 8388608,// T[K] Conditional = 16777216,// T extends U ? X : Y Substitution = 33554432,// Type parameter substitution NonPrimitive = 67108864,// intrinsic object type TemplateLiteral = 134217728,// Template literal type StringMapping = 268435456,// Used by union/intersection type construction LpcDocVariable = -2147483648, Literal = 2944, Unit = 101280, Freshable = 2976, StringOrNumberLiteral = 384, PossiblyFalsy = 121820, StringLike = 402653316, NumberLike = 2344, BooleanLike = 528, EnumLike = 1056, VoidLike = 49152, BytesLike = 12288, UnionOrIntersection = 3145728, StructuredType = 3670016, TypeVariable = 8650752, InstantiableNonPrimitive = 58982400, InstantiablePrimitive = 406847488, Instantiable = 465829888, StructuredOrInstantiable = 469499904, Narrowable = 536624063 } export declare const enum TypeFormatFlags { None = 0, NoTruncation = 1,// Don't truncate typeToString result WriteArrayAsGenericType = 2,// Write Array instead T[] GenerateNamesForShadowedTypeParams = 4,// When a type parameter T is shadowing another T, generate a name for it so it can still be referenced UseStructuralFallback = 8,// When an alias cannot be named by its symbol, rather than report an error, fallback to a structural printout if possible WriteTypeArgumentsOfSignature = 32,// Write the type arguments instead of type parameters of the signature UseFullyQualifiedType = 64,// Write out the fully qualified type name (eg. Module.Type, instead of Type) SuppressAnyReturnType = 256,// If the return type is any-like, don't offer a return type. MultilineObjectLiterals = 1024,// Always print object literals across multiple lines (only used to map into node builder flags) WriteClassExpressionAsTypeLiteral = 2048,// Write a type literal instead of (Anonymous class) UseTypeOfFunction = 4096,// Write typeof instead of function type literal OmitParameterModifiers = 8192,// Omit modifiers on parameters UseAliasDefinedOutsideCurrentScope = 16384,// For a `type T = ... ` defined in a different file, write `T` instead of its value, even though `T` can't be accessed in the current scope. UseSingleQuotesForStringLiteralType = 268435456,// Use single quotes for string literal type NoTypeReduction = 536870912,// Don't call getReducedType OmitThisParameter = 33554432, AllowUniqueESSymbolType = 1048576,// This is bit 20 to align with the same bit in `NodeBuilderFlags` AddUndefined = 131072,// Add undefined to types of initialized, non-optional parameters WriteArrowStyleSignature = 262144,// Write arrow style signature InArrayType = 524288,// Writing an array element type InElementType = 2097152,// Writing an array or union element type InFirstTypeArgument = 4194304,// Writing first type argument of the instantiated type InTypeAlias = 8388608,// Writing type in type alias declaration NodeBuilderFlagsMask = 848330095 } export declare const enum NodeFlags { None = 0, Variable = 1,// Variable declaration ExternalFile = 4,// Included from an external file Synthesized = 16,// Node was synthesized during transformation IncludeContext = 32,// Node was parsed from an include file MacroContext = 64,// Node was parsed as a result of a macro expansion ExportContext = 128,// Export context (initialized by binding) HasImplicitReturn = 512,// If function implicitly returns on one of codepaths (initialized by binding) HasExplicitReturn = 1024,// If function has explicit reachable return on one of codepaths (initialized by binding) HasAsyncFunctions = 4096,// If the file has async (i.e. LD coroutine) functions (initialized by binding) DisallowInContext = 8192,// If node was parsed in a context where 'in-expressions' are not allowed YieldContext = 16384,// If node was parsed in the 'yield' context created when parsing a generator DisallowTypes = 32768,// If node was parsed in a context where types are not allowed AwaitContext = 65536,// If node was parsed in the 'await' context created when parsing an async function DisallowCommaContext = 131072,// If node was parsed in a context where comma expr are not allow ThisNodeHasError = 262144,// If the parser encountered an error when parsing the code that created this node DisallowConditionalTypesContext = 524288, ThisNodeOrAnySubNodesHasError = 1048576,// If this node or any of its children had an error HasAggregatedChildData = 2097152,// If we've computed data from children and cached it in this node OptionalChain = 4194304,// not used DisallowPipeContext = 8388608,// If node was parsed in a context where '|' operators are not allowed CatchContext = 16777216,// If node was parsed in the 'catch' context created when parsing a catch clause JSDoc = 33554432,// If has '@deprecated' JSDoc tag ReachabilityCheckFlags = 1536, ReachabilityAndEmitFlags = 1536, ContextFlags = 67887200, BlockScoped = 1,// Indicates whether the identifier is part of a JSDoc namespace IncludeOrMacro = 96 } export declare const enum EmitFlags { None = 0, SingleLine = 1,// The contents of this node should be emitted on a single line. MultiLine = 2, AdviseOnEmitNode = 4,// The printer should invoke the onEmitNode callback when printing this node. NoSubstitution = 8,// Disables further substitution of an expression. CapturesThis = 16,// The function captures a lexical `this` NoLeadingSourceMap = 32,// Do not emit a leading source map location for this node. NoTrailingSourceMap = 64,// Do not emit a trailing source map location for this node. NoSourceMap = 96,// Do not emit a source map location for this node. NoNestedSourceMaps = 128,// Do not emit source map locations for children of this node. NoTokenLeadingSourceMaps = 256,// Do not emit leading source map location for token nodes. NoTokenTrailingSourceMaps = 512,// Do not emit trailing source map location for token nodes. NoTokenSourceMaps = 768,// Do not emit source map locations for tokens of this node. NoLeadingComments = 1024,// Do not emit leading comments for this node. NoTrailingComments = 2048,// Do not emit trailing comments for this node. NoComments = 3072,// Do not emit comments for this node. NoNestedComments = 4096, HelperName = 8192,// The Identifier refers to an *unscoped* emit helper (one that is emitted at the top of the file) ExportName = 16384,// Ensure an export prefix is added for an identifier that points to an exported declaration with a local name (see SymbolFlags.ExportHasLocal). LocalName = 32768,// Ensure an export prefix is not added for an identifier that points to an exported declaration. InternalName = 65536,// The name is internal to an ES5 class body function. Indented = 131072,// Adds an explicit extra indentation level for class and function bodies when printing (used to match old emitter). NoIndentation = 262144,// Do not indent the node. AsyncFunctionBody = 524288, ReuseTempVariableScope = 1048576,// Reuse the existing temp variable scope during emit. CustomPrologue = 2097152,// Treat the statement as if it were a prologue directive (NOTE: Prologue directives are *not* transformed). NoHoisting = 4194304,// Do not hoist this declaration in --module system Iterator = 8388608,// The expression to a `yield*` should be treated as an Iterator when down-leveling, not an Iterable. NoAsciiEscaping = 16777216 } export declare const enum ModifierFlags { None = 0, Public = 1,// Property/Method Private = 2,// Property/Method Protected = 4,// Property/Method NoMask = 32,// NoShadow = 64,// NoSave = 128,// Static = 256,// Property/Method VarArgs = 512, Visible = 1024, Export = 2048,// Declarations Ambient = 4096, Readonly = 8192, In = 16384,// Contravariance modifier Out = 32768,// Covariance modifier Deprecated = 65536, HasComputedJSDocModifiers = 268435456,// Indicates the computed modifier flags include modifiers from JSDoc. HasComputedFlags = 536870912,// Modifier flags have been computed AccessibilityModifier = 7, ParameterPropertyModifier = 167, NonPublicAccessibilityModifier = 6, All = 67559, Modifier = 67559 } export declare const enum ElementFlags { Required = 1,// T Optional = 2,// T? Rest = 4,// ...T[] Variadic = 8,// ...T Fixed = 3, Variable = 12, NonRequired = 14, NonRest = 11 } export type KeywordTypeSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.IntKeyword | SyntaxKind.FloatKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.BytesKeyword | SyntaxKind.MappingKeyword | SyntaxKind.StatusKeyword | SyntaxKind.LwObjectKeyword | SyntaxKind.ClosureKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.BufferKeyword | SyntaxKind.MixedKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.UnknownKeyword | SyntaxKind.NeverKeyword | SyntaxKind.VoidKeyword; export type TokenSyntaxKind = SyntaxKind.Unknown | SyntaxKind.EndOfFileToken | TriviaSyntaxKind | LiteralSyntaxKind | PunctuationSyntaxKind | SyntaxKind.Identifier | KeywordSyntaxKind; export type TypeNodeSyntaxKind = KeywordTypeSyntaxKind | SyntaxKind.TupleType | SyntaxKind.InferType | SyntaxKind.UnionType | SyntaxKind.NamedTupleMember | SyntaxKind.IndexedAccessType | SyntaxKind.StructType | SyntaxKind.ArrayType | SyntaxKind.MappingType | SyntaxKind.LiteralType | SyntaxKind.ThisType | SyntaxKind.TypePredicate | SyntaxKind.MappedType | SyntaxKind.TypeLiteral | SyntaxKind.ParenthesizedType | SyntaxKind.TypeReference | SyntaxKind.ExpressionWithTypeArguments | SyntaxKind.FunctionType | SyntaxKind.ConditionalType | SyntaxKind.IntersectionType | SyntaxKind.NamedObjectType | SyntaxKind.JSDocTypeExpression | SyntaxKind.JSDocAllType | SyntaxKind.JSDocUnknownType | SyntaxKind.JSDocNonNullableType | SyntaxKind.JSDocNullableType | SyntaxKind.JSDocOptionalType | SyntaxKind.JSDocFunctionType | SyntaxKind.JSDocVariadicType | SyntaxKind.JSDocNamepathType | SyntaxKind.JSDocSignature | SyntaxKind.JSDocTypeLiteral; export type PropertyName = Identifier | StringLiteral | IntLiteral | ComputedPropertyName | ParenthesizedExpression; export type MemberName = Identifier; export type DeclarationName = PropertyName | StringLiteral | Expression | ElementAccessExpression | BindingPattern | EntityNameExpression; export interface Symbol { flags: SymbolFlags; name: string; declarations?: Declaration[]; valueDeclaration?: Declaration; members?: SymbolTable; exports?: SymbolTable; inherits?: Map; globalExports?: SymbolTable; } export interface TrueLiteral extends PrimaryExpression { readonly kind: SyntaxKind.TrueKeyword; } export interface FalseLiteral extends PrimaryExpression { readonly kind: SyntaxKind.FalseKeyword; } export interface NodeFactory { createSourceFile(statements: readonly Statement[], endOfFileToken: EndOfFileToken, flags: NodeFlags): SourceFile; createNodeArray(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray; createIntLiteral(value: string | number, numericLiteralFlags?: TokenFlags): IntLiteral; createFloatLiteral(value: string | number, numericLiteralFlags?: TokenFlags): FloatLiteral; createStringLiteral(text: string): StringLiteral; createBytesLiteral(text: string): BytesLiteral; createStringLiteralFromNode(sourceNode: PropertyNameLiteral, isSingleQuote?: boolean): StringLiteral; createTrue(): TrueLiteral; createFalse(): FalseLiteral; createToken(token: SyntaxKind.EndOfFileToken): EndOfFileToken; createToken(token: SyntaxKind.Unknown): Token; createIdentifier(text: string): Identifier; createLiteralLikeNode(kind: LiteralToken["kind"], text: string): LiteralToken; createEmptyStatement(): EmptyStatement; createModifier(kind: T): ModifierToken; createModifiersFromModifierFlags(flags: ModifierFlags): Modifier[] | undefined; createQualifiedName(left: EntityName, right: string | Identifier): QualifiedName; createComputedPropertyName(expression: Expression): ComputedPropertyName; updateComputedPropertyName(node: ComputedPropertyName, expression: Expression): ComputedPropertyName; createIndexSignature(modifiers: readonly Modifier[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): IndexSignatureDeclaration; createTypeParameterDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier, constraint?: TypeNode, defaultType?: TypeNode): TypeParameterDeclaration; updateTypeParameterDeclaration(node: TypeParameterDeclaration, modifiers: readonly Modifier[] | undefined, name: Identifier, constraint: TypeNode | undefined, defaultType: TypeNode | undefined): TypeParameterDeclaration; createMethodSignature(modifiers: readonly Modifier[] | undefined, name: string | PropertyName, questionToken: QuestionToken | undefined, typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): MethodSignature; createCallSignature(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined): CallSignatureDeclaration; createFunctionTypeNode(typeParameters: readonly TypeParameterDeclaration[] | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode): FunctionTypeNode; createBindingElement(dotDotDotToken: DotDotDotToken | undefined, propertyName: string | PropertyName | undefined, name: string | BindingName, initializer?: Expression): BindingElement; updateBindingElement(node: BindingElement, dotDotDotToken: DotDotDotToken | undefined, propertyName: PropertyName | undefined, name: BindingName, initializer: Expression | undefined): BindingElement; createIncludeDirective(content: StringLiteral[], localFirst: boolean): IncludeDirective; createPragmaDirective(expression: NodeArray): PragmaDirective; createDefineDirective(name: string | Identifier | TypeNode, args: NodeArray, range: TextRange): DefineDirective; createUndefDirective(name: string | Identifier): UndefDirective; createTypePredicateNode(assertsModifier: undefined, parameterName: Identifier | ThisTypeNode | string, type: TypeNode | undefined): TypePredicateNode; updateTypePredicateNode(node: TypePredicateNode, assertsModifier: undefined, parameterName: Identifier | ThisTypeNode, type: TypeNode | undefined): TypePredicateNode; createKeywordTypeNode(kind: TKind): KeywordTypeNode; createTypeReferenceNode(typeName: string | EntityName, typeArguments?: readonly TypeNode[]): TypeReferenceNode; updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray | undefined): TypeReferenceNode; createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode; createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode; createArrayTypeNode(elementType: TypeNode): ArrayTypeNode; createMappingTypeNode(keyType: TypeNode, valueTypes: NodeArray): MappingTypeNode; createNamedObjectTypeNode(name: StringLiteral | BinaryExpression | ParenthesizedExpression, objectKeyword: TypeNode): NamedObjectTypeNode; createParenthesizedType(type: TypeNode): ParenthesizedTypeNode; createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode; createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode; createStructTypeNode(name: Identifier, keyword: StructKeywordSyntaxKind): StructTypeNode; createPropertySignature(modifiers: readonly Modifier[] | undefined, name: PropertyName | string, type: TypeNode | undefined): PropertySignature; createStructDeclarationNode(modifiers: readonly Modifier[] | undefined, name: Identifier, heritageName: Identifier | undefined, type: TypeNode): StructDeclaration; createBlock(statements: readonly Statement[], multiLine?: boolean): Block; createVariableStatement(modifiers: readonly Modifier[] | undefined, type: TypeNode | undefined, declarationList: VariableDeclarationList | readonly VariableDeclaration[]): VariableStatement; createVariableDeclarationList(declarations: readonly VariableDeclaration[], flags?: NodeFlags): VariableDeclarationList; createVariableDeclaration(name: string | BindingName, refToken?: RefToken, type?: TypeNode | undefined, initializer?: Expression | undefined): VariableDeclaration; createFunctionDeclaration(modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, parameters: readonly ParameterDeclaration[], type: TypeNode | undefined, body: Block | undefined): FunctionDeclaration; createExpressionStatement(expression: Expression): ExpressionStatement; createReturnStatement(expression?: Expression): ReturnStatement; createBreakStatement(label?: string | Identifier): BreakStatement; createContinueStatement(label?: string | Identifier): ContinueStatement; createInheritDeclaration(importClause: InheritClauseNodeType, modifiers: readonly Modifier[] | undefined): InheritDeclaration; createIfStatement(expression: Expression, thenStatement: Statement, elseStatement?: Statement): IfStatement; createSwitchStatement(expression: Expression, preBlock: NodeArray, caseBlock: CaseBlock): SwitchStatement; createCaseBlock(clauses: readonly CaseOrDefaultClause[]): CaseBlock; createDefaultClause(statements: readonly Statement[]): DefaultClause; createCaseClause(expression: Expression, statements: readonly Statement[]): CaseClause; createForStatement(initializer: ForInitializer | undefined, condition: Expression | undefined, incrementor: Expression | undefined, statement: Statement): ForStatement; createForEachStatement(initializer: ForInitializer | undefined, range: Expression | undefined, statement: Statement): ForEachStatement; createDoWhileStatement(statement: Statement, expression: Expression): DoWhileStatement; createWhileStatement(statement: Statement, expression: Expression): WhileStatement; createParameterDeclaration(modifiers: readonly Modifier[] | undefined, dotDotDotToken: DotDotDotToken | undefined, name: string | BindingName, ampToken?: AmpersandToken | RefToken, type?: TypeNode, initializer?: Expression): ParameterDeclaration; createCatchStatement(expression: Expression | undefined, block: Block, modifier?: Identifier, modifierExpression?: Expression): CatchStatement; createExpressionWithTypeArguments(expression: Expression, typeArguments: readonly TypeNode[] | undefined): ExpressionWithTypeArguments; createCatchExpression(expression: Expression, modifier?: Identifier, modifierExpression?: Expression, block?: Block): CatchExpression; createEvaluateExpression(expression: Expression, argumentsArray: readonly Expression[] | undefined): EvaluateExpression; createNewExpression(expression: Expression | TypeNode | undefined, typeArguments: readonly TypeNode[] | undefined, argumentsArray: readonly NewExpressionArgument[] | undefined): NewExpression; createSpreadElement(expression: Expression): SpreadElement; createByRefElement(ampToken: AmpersandToken | RefToken, expr: Expression): ByRefElement; createFunctionExpression(modifiers: readonly Modifier[] | undefined, name: string | Identifier | undefined, parameters: readonly ParameterDeclaration[] | undefined, type: TypeNode | undefined, body: Block): FunctionExpression; createOmittedExpression(): OmittedExpression; createParenthesizedExpression(expression: Expression): ParenthesizedExpression; createConditionalExpression(condition: Expression, questionToken: QuestionToken | undefined, whenTrue: Expression, colonToken: ColonToken | undefined, whenFalse: Expression): ConditionalExpression; createBinaryExpression(left: Expression, operator: BinaryOperator | BinaryOperatorToken, right: Expression): BinaryExpression; createCallExpression(expression: Expression, argumentsArray: readonly Expression[] | undefined): CallExpression; createInlineClosure(body: ConciseBody | NodeArray): InlineClosureExpression; createSuperAccessExpression(name: MemberName, namespace?: string | StringLiteral | Identifier): SuperAccessExpression; createPropertyAccessExpression(expression: Expression, name: string | Identifier | Expression, propertyAccessToken?: PropertyAccessToken): PropertyAccessExpression; createPrefixUnaryExpression(operator: PrefixUnaryOperator, operand: Expression): PrefixUnaryExpression; createPostfixUnaryExpression(operand: Expression, operator: PostfixUnaryOperator): PostfixUnaryExpression; createElementAccessExpression(expression: Expression, index: number | Expression): ElementAccessExpression; createArrayLiteralExpression(elements?: readonly Expression[], multiLine?: boolean, trailingComma?: boolean): any; createObjectLiteralExpression(properties?: readonly ObjectLiteralElementLike[], multiLine?: boolean): ObjectLiteralExpression; createMappingLiteralExpression(initializer?: Expression, elements?: readonly Expression[], multiLine?: boolean, trailingComma?: boolean): MappingLiteralExpression; createMappingEntryExpression(name: Expression, elements: readonly Expression[]): MappingEntryExpression; convertToAssignmentExpression(node: Mutable): BinaryExpression; createLambdaOperatorExpression(op: LambdaOperatorToken): LambdaOperatorExpression; createLambdaIdentifierExpression(name: Expression): LambdaIdentifierExpression; createCastExpression(expression: Expression, type: TypeNode): Expression; createCloneObjectExpression(expression: Expression, argumentsArray: readonly Expression[] | undefined): CloneObjectExpression; createTypeAssertion(type: TypeNode, expression: Expression): TypeAssertion; createNewStructExpression(type: StructTypeNode, argumentsArray: readonly (Expression | ObjectLiteralElementLike)[] | undefined): NewStructExpression; createRangeExpression(left: Expression, right: Expression): RangeExpression; createJSDocText(text: string): JSDocText; createJSDocComment(comment?: string | NodeArray | undefined, tags?: readonly JSDocTag[] | undefined): JSDoc; createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, defaultExpression: Expression | undefined, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray): JSDocParameterTag; createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string | NodeArray): JSDocReturnTag; createJSDocOptionalType(type: TypeNode): JSDocOptionalType; createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocTypeTag; createJSDocTypeExpression(type: TypeNode): JSDocTypeExpression; createJSDocNameReference(name: EntityName | JSDocMemberName): JSDocNameReference; createJSDocLink(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLink; createJSDocLinkCode(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkCode; createJSDocLinkPlain(name: EntityName | JSDocMemberName | undefined, text: string): JSDocLinkPlain; createJSDocClassTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocClassTag; createJSDocPublicTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocPublicTag; createJSDocPrivateTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocPrivateTag; createJSDocProtectedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocProtectedTag; createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocDeprecatedTag; createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocOverrideTag; createJSDocUnknownTag(tagName: Identifier, comment?: string | NodeArray): JSDocUnknownTag; createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray): JSDocPropertyTag; createJSDocVariableTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray): JSDocVariableTag; createJSDocTypeLiteral(propertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral; createJSDocSeeTag(tagName: Identifier | undefined, name: JSDocNameReference | undefined, comment?: string | NodeArray): JSDocSeeTag; createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string | NodeArray): JSDocAuthorTag; createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray): JSDocThrowsTag; createJSDocImplementsTag(tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment?: string | NodeArray): JSDocImplementsTag; createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier, comment?: string | NodeArray): JSDocTypedefTag; createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment?: string | NodeArray): JSDocAugmentsTag; createJSDocSatisfiesTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocSatisfiesTag; createJSDocThisTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray): JSDocThisTag; createJSDocVariadicType(type: TypeNode): JSDocVariadicType; createJSDocSignature(typeParameters: readonly JSDocTemplateTag[] | undefined, parameters: readonly JSDocParameterTag[], type?: JSDocReturnTag): JSDocSignature; createJSDocCallbackTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, fullName?: Identifier, comment?: string | NodeArray): JSDocCallbackTag; createJSDocOverloadTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, comment?: string | NodeArray): JSDocOverloadTag; createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray): JSDocTemplateTag; createPropertyAssignment(name: string | PropertyName, initializer: Expression): PropertyAssignment; } export interface CompilerOptions { skipLibCheck?: boolean; skipDefaultLibCheck?: boolean; allowArbitraryExtensions?: boolean; traceResolution?: boolean; allowUnreachableCode?: boolean; noUncheckedIndexedAccess?: boolean; noFallthroughCasesInSwitch?: boolean; noCheck?: boolean; noUnusedLocals?: boolean; noUnusedParameters?: boolean; noImplicitReturns?: boolean; strictObjectTypes?: boolean; newLine?: NewLineKind; configFile?: LpcConfigSourceFile; sefunFile?: string; masterFile?: string; playerFile?: string; configDefines?: MapLike; forceConsistentCasingInFileNames?: boolean; noResolve?: boolean; noLib?: boolean; maxNodeModuleJsDepth?: number; getCompilationSettings?: any; configFilePath?: string; driverType?: LanguageVariant; rootDir?: string; rootDirs?: string[]; outDir?: string; declarationDir?: string; outFile?: string; paths?: MapLike; lib?: string[]; preserveSymlinks?: boolean; disableSourceOfProjectReferenceRedirect?: boolean; disableReferencedProjectLoad?: boolean; module?: ModuleKind; target?: ScriptTarget; exactOptionalPropertyTypes?: boolean; diagnostics?: boolean; libIncludeDirs?: string[]; globalIncludeFiles?: string[]; resolvedGlobalIncludeFiles?: string[]; [option: string]: CompilerOptionsValue | LpcConfigSourceFile | undefined; } export declare const enum OuterExpressionKinds { Parentheses = 1, /** @deprecated not supported in lpc */ TypeAssertions = 2, /** @deprecated not supported in lpc */ NonNullAssertions = 4, PartiallyEmittedExpressions = 8, Assertions = 6, All = 15, ExcludeJSDocTypeAssertion = 16 } /** DIAGNOSTICS */ export interface DiagnosticMessage { key: string; category: DiagnosticCategory; code: number; message: string; reportsUnnecessary?: {}; reportsDeprecated?: {}; } export declare enum DiagnosticCategory { Warning = 0, Error = 1, Suggestion = 2, Message = 3 } export interface DiagnosticRelatedInformation { category: DiagnosticCategory; code: number; file: SourceFileBase | undefined; start: number | undefined; length: number | undefined; messageText: string | DiagnosticMessageChain; } export interface DiagnosticWithLocation extends Diagnostic { file: SourceFileBase; start: number; length: number; } /** * A linked list of formatted diagnostic messages to be used as part of a multiline message. * It is built from the bottom up, leaving the head to be the "main" diagnostic. * While it seems that DiagnosticMessageChain is structurally similar to DiagnosticMessage, * the difference is that messages are all preformatted in DMC. */ export interface DiagnosticMessageChain { messageText: string; category: DiagnosticCategory; code: number; next?: DiagnosticMessageChain[]; } export interface Diagnostic extends DiagnosticRelatedInformation { /** May store more in future. For now, this will simply be `true` to indicate when a diagnostic is an unused-identifier diagnostic. */ reportsUnnecessary?: {}; reportsDeprecated?: {}; source?: string; relatedInformation?: DiagnosticRelatedInformation[]; } export type FunctionLikeDeclaration = FunctionDeclaration | InlineClosureExpression | MethodDeclaration | FunctionExpression | ArrowFunction; /** NODES */ export type HasJSDoc = IncludeDirective | CatchStatement | FunctionExpression | SuperAccessExpression | DefineDirective | UndefDirective | Block | StructDeclaration | PropertySignature | MethodSignature | InlineClosureExpression | InheritDeclaration | SwitchStatement | CaseClause | BreakStatement | ContinueStatement | IfStatement | ParenthesizedExpression | ExpressionStatement | EmptyStatement | EndOfFileToken | DoWhileStatement | ForStatement | ForEachStatement | FunctionDeclaration | ArrowFunction | ReturnStatement | ParameterDeclaration | VariableStatement | VariableDeclaration | WhileStatement | PropertyAssignment | ElementAccessExpression | ShorthandPropertyAssignment; export type HasType = SignatureDeclaration | VariableStatement | VariableDeclaration | ParameterDeclaration | PropertySignature | PropertyDeclaration | ParenthesizedTypeNode | MappedTypeNode | AssertionExpression | TypeAliasDeclaration | JSDocTypeExpression | JSDocVariadicType; export type HasExpressionInitializer = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment; export type HasInitializer = HasExpressionInitializer | ForStatement | ForEachStatement; export type HasModifiers = TypeParameterDeclaration | ParameterDeclaration | StructDeclaration | FunctionLikeDeclaration | PropertySignature | PropertyDeclaration | MethodSignature | MethodDeclaration | IndexSignatureDeclaration | FunctionExpression | ArrowFunction | ClassExpression | VariableStatement | FunctionDeclaration | ClassDeclaration | TypeAliasDeclaration; export interface NodeArray extends ReadonlyArray, ReadonlyTextRange { readonly hasTrailingComma: boolean; readonly isComplete?: boolean; } export interface Token extends Node { readonly kind: TKind; } export type EndOfFileToken = Token & JSDocContainer; export type DirectiveSyntaxKind = SyntaxKind.IncludeDirective | SyntaxKind.DefineDirective | SyntaxKind.UndefDirective | SyntaxKind.IfDirective | SyntaxKind.IfDefDirective | SyntaxKind.IfNDefDirective | SyntaxKind.ElseDirective | SyntaxKind.ElseIfDirective | SyntaxKind.EndIfDirective | SyntaxKind.PragmaDirective; export type StructKeywordSyntaxKind = SyntaxKind.StructKeyword | SyntaxKind.ClassKeyword; export type KeywordSyntaxKind = SyntaxKind.AnyKeyword | SyntaxKind.TrueKeyword | SyntaxKind.FalseKeyword | SyntaxKind.FunctionsKeyword | SyntaxKind.VirtualKeyword | SyntaxKind.IsKeyword | SyntaxKind.RefKeyword | SyntaxKind.StatusKeyword | SyntaxKind.BytesKeyword | SyntaxKind.LwObjectKeyword | SyntaxKind.CatchKeyword | SyntaxKind.ClosureKeyword | SyntaxKind.SymbolKeyword | SyntaxKind.BufferKeyword | SyntaxKind.ClassKeyword | SyntaxKind.CaseKeyword | SyntaxKind.ClosureKeyword | SyntaxKind.DefaultKeyword | SyntaxKind.UndefinedKeyword | SyntaxKind.BreakKeyword | SyntaxKind.VoidKeyword | SyntaxKind.ContinueKeyword | SyntaxKind.DoKeyword | SyntaxKind.ElseKeyword | SyntaxKind.ForKeyword | SyntaxKind.ForEachKeyword | SyntaxKind.FunctionKeyword | SyntaxKind.IfKeyword | SyntaxKind.InKeyword | SyntaxKind.InheritKeyword | SyntaxKind.NewKeyword | SyntaxKind.NullKeyword | SyntaxKind.NeverKeyword | SyntaxKind.ReturnKeyword | SyntaxKind.SwitchKeyword | SyntaxKind.WhileKeyword | SyntaxKind.AsyncKeyword | SyntaxKind.IntrinsicKeyword | SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.StaticKeyword | SyntaxKind.VisibleKeyword | SyntaxKind.NoSaveKeyword | SyntaxKind.NoShadowKeyword | SyntaxKind.NoMaskKeyword | SyntaxKind.VarArgsKeyword | SyntaxKind.DeprecatedKeyword | SyntaxKind.IntKeyword | SyntaxKind.ObjectKeyword | SyntaxKind.StringKeyword | SyntaxKind.FloatKeyword | SyntaxKind.MixedKeyword | SyntaxKind.MappingKeyword | SyntaxKind.StructKeyword | SyntaxKind.UnknownKeyword; export type ModifierSyntaxKind = SyntaxKind.PrivateKeyword | SyntaxKind.ProtectedKeyword | SyntaxKind.PublicKeyword | SyntaxKind.StaticKeyword | SyntaxKind.VisibleKeyword | SyntaxKind.NoSaveKeyword | SyntaxKind.NoShadowKeyword | SyntaxKind.NoMaskKeyword | SyntaxKind.VarArgsKeyword | SyntaxKind.DeprecatedKeyword; export interface KeywordToken extends Token { } export interface KeywordTypeNode extends KeywordToken, TypeNode { readonly kind: TKind; } export type CaseKeyword = KeywordToken; export type RefToken = KeywordToken; export interface ModifierToken extends KeywordToken { } export type PrivateKeyword = ModifierToken; export type ProtectedKeyword = ModifierToken; export type PublicKeyword = ModifierToken; export type StaticKeyword = ModifierToken; export type VisibleKeyword = ModifierToken; export type NoSaveKeyword = ModifierToken; export type NoShadowKeyword = ModifierToken; export type NoMaskKeyword = ModifierToken; export type VarArgsKeyword = ModifierToken; export type DeprecatedKeyword = ModifierToken; export type Modifier = PrivateKeyword | ProtectedKeyword | PublicKeyword | StaticKeyword | VisibleKeyword | NoSaveKeyword | NoShadowKeyword | NoMaskKeyword | VarArgsKeyword | DeprecatedKeyword; /** * @deprecated for easy portion of typescript code - use Modifier */ export type ModifierLike = Modifier; export type PunctuationSyntaxKind = SyntaxKind.OpenParenBracketToken | SyntaxKind.OpenParenAsteriskToken | SyntaxKind.LambdaToken | SyntaxKind.OpenParenBraceToken | SyntaxKind.OpenBraceToken | SyntaxKind.CloseBraceToken | SyntaxKind.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.OpenParenColonToken | SyntaxKind.ColonCloseParenToken | 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.MinusGreaterThanToken | 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.DoubleExclamationToken | SyntaxKind.TildeToken | SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.BarBarEqualsToken | SyntaxKind.QuestionToken | SyntaxKind.ColonToken | SyntaxKind.AtToken | SyntaxKind.AtAtToken | 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.ColonToken | SyntaxKind.CaretEqualsToken; export type ExponentiationOperator = SyntaxKind.AsteriskAsteriskToken; export type MultiplicativeOperator = SyntaxKind.AsteriskToken | SyntaxKind.SlashToken | SyntaxKind.PercentToken; export type MultiplicativeOperatorOrHigher = ExponentiationOperator | MultiplicativeOperator; export type AdditiveOperator = SyntaxKind.PlusToken | SyntaxKind.MinusToken; export type AdditiveOperatorOrHigher = MultiplicativeOperatorOrHigher | AdditiveOperator; export type ShiftOperator = SyntaxKind.LessThanLessThanToken | SyntaxKind.GreaterThanGreaterThanToken | SyntaxKind.GreaterThanGreaterThanGreaterThanToken; export type ShiftOperatorOrHigher = AdditiveOperatorOrHigher | ShiftOperator; export type RelationalOperator = SyntaxKind.LessThanToken | SyntaxKind.LessThanEqualsToken | SyntaxKind.GreaterThanToken | SyntaxKind.GreaterThanEqualsToken | SyntaxKind.InKeyword; export type RelationalOperatorOrHigher = ShiftOperatorOrHigher | RelationalOperator; export type EqualityOperator = SyntaxKind.EqualsEqualsToken | SyntaxKind.EqualsEqualsEqualsToken | SyntaxKind.ExclamationEqualsEqualsToken | SyntaxKind.ExclamationEqualsToken; export type EqualityOperatorOrHigher = RelationalOperatorOrHigher | EqualityOperator; export type BitwiseOperator = SyntaxKind.AmpersandToken | SyntaxKind.BarToken | SyntaxKind.CaretToken; export type BitwiseOperatorOrHigher = EqualityOperatorOrHigher | BitwiseOperator; export type LogicalOperator = SyntaxKind.AmpersandAmpersandToken | SyntaxKind.BarBarToken | SyntaxKind.QuestionQuestionToken; export type LogicalOperatorOrHigher = BitwiseOperatorOrHigher | LogicalOperator; export 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 | SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken; export type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator; export type AssignmentOperatorOrHigher = LogicalOperatorOrHigher | AssignmentOperator; export type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken; export type BinaryOperatorToken = Token; export type LogicalOrCoalescingAssignmentOperator = SyntaxKind.BarBarEqualsToken | SyntaxKind.AmpersandAmpersandEqualsToken | SyntaxKind.QuestionQuestionEqualsToken; export type LambdaOperatorToken = Token; export interface PunctuationToken extends Token { } export type DotToken = PunctuationToken; export type AmpersandToken = PunctuationToken; export type DotDotDotToken = PunctuationToken; export type QuestionToken = PunctuationToken; export type ExclamationToken = PunctuationToken; export type DoubleExclamationToken = PunctuationToken; export type ColonToken = PunctuationToken; export type EqualsToken = PunctuationToken; export type BarBarEqualsToken = PunctuationToken; export type AsteriskToken = PunctuationToken; export type EqualsGreaterThanToken = PunctuationToken; export type MinusGreaterThanToken = PunctuationToken; export type PlusToken = PunctuationToken; export type MinusToken = PunctuationToken; export type PropertyAccessToken = DotToken | MinusGreaterThanToken; export type JSDocImportCandidateNode = JSDocParameterTag | JSDocTypeTag | JSDocTypedefTag | JSDocVariableTag | JSDocPropertyTag | JSDocReturnTag; 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.OpenParenToken | SyntaxKind.CloseParenToken | SyntaxKind.EqualsToken | SyntaxKind.CommaToken | SyntaxKind.DotToken | SyntaxKind.Identifier | SyntaxKind.BacktickToken | SyntaxKind.HashToken | SyntaxKind.Unknown | KeywordSyntaxKind; export interface ConditionalExpression extends Expression { readonly kind: SyntaxKind.ConditionalExpression; readonly condition: Expression; readonly questionToken: QuestionToken; readonly whenTrue: Expression; readonly colonToken: ColonToken; readonly whenFalse: Expression; } export interface FlowContainer extends Node { _flowContainerBrand: any; } export type FlowType = Type | IncompleteType; export interface IncompleteType { flags: TypeFlags | 0; type: Type; } export interface LineAndCharacter { /** 0-based. */ line: number; character: number; } /** * Subset of properties from SourceFile that are used in multiple utility functions */ export interface SourceFileLike { readonly text: string; readonly fileName: string; } export type SourceFileBaseSyntaxKind = SyntaxKind.SourceFile | SyntaxKind.IncludeDirective; export interface SourceFileBase { readonly kind: SourceFileBaseSyntaxKind; readonly text: string; readonly fileName: string; languageVersion: ScriptTarget; languageVariant: LanguageVariant; } export interface HasHeritageContainer { _hasHeritageBrand: any; heritageClauses?: NodeArray; } export interface SourceFile extends Declaration, LocalsContainer, HasHeritageContainer, SourceFileBase { readonly kind: SyntaxKind.SourceFile; readonly statements: NodeArray; readonly endOfFileToken: Token; fileName: string; text: string; referencedFiles: readonly FileReference[]; libReferenceDirectives: readonly FileReference[]; isDeclarationFile: boolean; isDefaultLib: boolean; languageVersion: ScriptTarget; languageVariant: LanguageVariant; /** * When `module` is `Node16` or `NodeNext`, this field controls whether the * source file in question is an ESNext-output-format file, or a CommonJS-output-format * module. This is derived by the module resolver as it looks up the file, since * it is derived from either the file extension of the module, or the containing * `package.json` context, and affects both checking and emit. * * It is _public_ so that (pre)transformers can set this field, * since it switches the builtin `node` module transform. Generally speaking, if unset, * the field is treated as though it is `ModuleKind.CommonJS`. * * Note that this field is only set by the module resolution process when * `moduleResolution` is `Node16` or `NodeNext`, which is implied by the `module` setting * of `Node16` or `NodeNext`, respectively, but may be overriden (eg, by a `moduleResolution` * of `node`). If so, this field will be unset and source files will be considered to be * CommonJS-output-format by the node module transformer and type checker, regardless of extension or context. */ impliedNodeFormat?: ResolutionMode; /** * Array of text ranges that are inactive due to directives */ inactiveCodeRanges?: readonly TextRange[]; /** Macros that were parsed in this source file (and any includes) */ parsedMacros?: ReadonlyMap; /** When a node is parsed as a result of a macro expansion, a link from the node * to the original macro definition is stored here. */ nodeMacroMap?: ReadonlyMap; } export interface JsonSourceFile extends SourceFile { readonly statements: NodeArray; } export type JsonObjectExpression = ObjectLiteralExpression | ArrayLiteralExpression | JsonMinusNumericLiteral | NumericLiteral | StringLiteral | BooleanLiteral | NullLiteral; export interface JsonMinusNumericLiteral extends PrefixUnaryExpression { readonly kind: SyntaxKind.PrefixUnaryExpression; readonly operator: SyntaxKind.MinusToken; readonly operand: NumericLiteral; } /** * JSON-only */ export interface NumericLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.NumericLiteral; } /** * JSON only */ export interface NullLiteral extends PrimaryExpression { readonly kind: SyntaxKind.NullKeyword; } export interface JsonObjectExpressionStatement extends ExpressionStatement { readonly expression: JsonObjectExpression; } export interface CheckLpcDirective extends TextRange { enabled: boolean; } export type CommentKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia; export interface CommentRange extends TextRange { hasTrailingNewLine?: boolean; kind: CommentKind; } export interface FileReference extends TextRange { fileName: string; preserve?: boolean; } export interface LiteralLikeNode extends Node { text: string; isUnterminated?: boolean; hasExtendedUnicodeEscape?: boolean; } export type ImportCandidateNode = CloneObjectExpression | PropertyAccessExpression | NewExpression | InheritDeclaration | IncludeDirective | CallExpression | NamedObjectTypeNode | JSDocParameterTag | JSDocTypeTag | JSDocTypedefTag | JSDocPropertyTag | JSDocVariableTag | JSDocReturnTag; export declare const enum TokenFlags { None = 0,// e.g. `\u{10ffff}` Scientific = 16,// e.g. `10e2` Octal = 32,// e.g. `0777` HexSpecifier = 64,// e.g. `0x00000000` BinarySpecifier = 128,// e.g. `0b0110010000000000` OctalSpecifier = 256 } export declare const enum SymbolFlags { None = 0, FunctionScopedVariable = 1,// Variable (var) or parameter BlockScopedVariable = 2,// A block-scoped variable (let or const) Property = 4,// Property or enum member EnumMember = 8,// Enum member Function = 16,// Function Class = 32,// Class Interface = 64,// Interface ConstEnum = 128,// Const enum RegularEnum = 256,// Enum ValueModule = 512,// Instantiated module NamespaceModule = 1024,// Uninstantiated module TypeLiteral = 2048,// Type Literal or mapped type ObjectLiteral = 4096,// Object Literal Method = 8192,// Method Constructor = 16384,// Constructor GetAccessor = 32768,// Get accessor SetAccessor = 65536,// Set accessor Signature = 131072,// Call, construct, or index signature TypeParameter = 262144,// Type parameter TypeAlias = 524288,// Type alias ExportValue = 1048576,// Exported value marker (see comment in declareModuleMember in binder) Alias = 2097152,// An alias for another symbol (see comment in isAliasSymbolDeclaration in checker) Prototype = 4194304,// Prototype property (no source representation) FakeGlobal = 8388608,// A fake symbol created for global type purposes Optional = 16777216,// Optional property Transient = 33554432,// Transient symbol (created during type check) Assignment = 67108864,// Assignment treated as declaration (eg `this.prop = 1`) ModuleExports = 134217728,// Symbol for CommonJS `module` of `module.exports` Define = 268435456,// Define macro All = -1, Enum = 384, Variable = 3, Value = 111551, ValueOrDefine = 268547007, Type = 788968, Namespace = 1920, Module = 1536, Accessor = 98304, FunctionScopedVariableExcludes = 111550, BlockScopedVariableExcludes = 268547007, ParameterExcludes = 111551, PropertyExcludes = 0, EnumMemberExcludes = 900095, FunctionExcludes = 110991, DefineExcludes = 111039, ClassExcludes = 899503,// class-interface mergability done in checker.ts InterfaceExcludes = 788872, RegularEnumExcludes = 899327,// regular enums merge only with regular enums and modules ConstEnumExcludes = 899967,// const enums merge only with const enums ValueModuleExcludes = 110735, NamespaceModuleExcludes = 0, MethodExcludes = 103359, GetAccessorExcludes = 46015, SetAccessorExcludes = 78783, AccessorExcludes = 13247, TypeParameterExcludes = 526824, TypeAliasExcludes = 788968, AliasExcludes = 2097152, ModuleMember = 2623475, ExportHasLocal = 944, BlockScoped = 418, PropertyOrAccessor = 98308, ClassMember = 106500 } export interface LiteralExpression extends LiteralLikeNode, PrimaryExpression { _literalExpressionBrand: any; } export interface IntLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.IntLiteral; } export interface FloatLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.FloatLiteral; } export type PropertyNameLiteral = Identifier | StringLiteral | IntLiteral; export interface StringLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.StringLiteral; } export interface BytesLiteral extends LiteralExpression, Declaration { readonly kind: SyntaxKind.BytesLiteral; } export type TriviaSyntaxKind = SyntaxKind.SingleLineCommentTrivia | SyntaxKind.MultiLineCommentTrivia | SyntaxKind.NewLineTrivia | SyntaxKind.WhitespaceTrivia | SyntaxKind.ShebangTrivia | SyntaxKind.ConflictMarkerTrivia; export type StringLiteralLike = StringLiteral; export type LiteralToken = IntLiteral | FloatLiteral | StringLiteral | BytesLiteral; export type LiteralSyntaxKind = SyntaxKind.IntLiteral | SyntaxKind.FloatLiteral | SyntaxKind.BytesLiteral | SyntaxKind.StringLiteral; export interface TypeNode extends Node { _typeNodeBrand: any; } export interface UnionTypeNode extends TypeNode { readonly kind: SyntaxKind.UnionType; readonly types: NodeArray; } export interface IntersectionTypeNode extends TypeNode { readonly kind: SyntaxKind.IntersectionType; readonly types: NodeArray; } export interface ArrayTypeNode extends TypeNode { readonly kind: SyntaxKind.ArrayType; readonly elementType: TypeNode; } export interface NamedObjectTypeNode extends TypeNode { readonly kind: SyntaxKind.NamedObjectType; readonly objectKeyword: TypeNode; readonly name: StringLiteral | BinaryExpression | ParenthesizedExpression; } export interface JSDocContainer extends Node { _LpcjsDocContainerBrand: any; } export interface JSDocType extends TypeNode { _jsDocTypeBrand: any; } export type EntityName = Identifier | QualifiedName; export interface JSDocPropertyLikeTag extends JSDocTag, Declaration { readonly parent: JSDoc; readonly name: EntityName; readonly defaultExpression: Expression | undefined; readonly typeExpression?: JSDocTypeExpression; /** Whether the property name came before the type -- non-standard for JSDoc, but Typescript-like */ readonly isNameFirst: boolean; readonly isBracketed: boolean; } export interface JSDocTypeExpression extends TypeNode { readonly kind: SyntaxKind.JSDocTypeExpression; readonly type: TypeNode; } export interface JSDocTypeLiteral extends JSDocType, Declaration { readonly kind: SyntaxKind.JSDocTypeLiteral; readonly jsDocPropertyTags?: readonly JSDocPropertyLikeTag[]; /** If true, then this type literal represents an *array* of its type. */ readonly isArrayType: boolean; } export interface JSDocTag extends Node { readonly parent: JSDoc | JSDocTypeLiteral; readonly tagName: Identifier; readonly comment?: string | NodeArray; } export interface JSDoc extends Node { readonly kind: SyntaxKind.JSDoc; readonly parent: HasJSDoc; readonly tags?: NodeArray; readonly comment?: string | NodeArray; } export interface JSDocTypedefTag extends JSDocTag, NamedDeclaration, LocalsContainer { readonly kind: SyntaxKind.JSDocTypedefTag; readonly parent: JSDoc; readonly fullName?: Identifier; readonly name?: Identifier; readonly typeExpression?: JSDocTypeExpression | JSDocTypeLiteral; } export interface JSDocMemberName extends Node { readonly kind: SyntaxKind.JSDocMemberName; readonly left: EntityName | JSDocMemberName; readonly right: Identifier; } export interface JSDocText extends Node { readonly kind: SyntaxKind.JSDocText; text: string; } export type JSDocComment = JSDocText | JSDocLink | JSDocLinkCode | JSDocLinkPlain; export interface Expression extends Node { _expressionBrand: any; } export interface OmittedExpression extends Expression { readonly kind: SyntaxKind.OmittedExpression; } export interface CastExpression extends Expression { readonly kind: SyntaxKind.CastExpression; readonly expression: Expression; readonly type: TypeNode; } export interface PartiallyEmittedExpression extends LeftHandSideExpression { readonly kind: SyntaxKind.PartiallyEmittedExpression; readonly expression: Expression; } export interface TypeAssertion extends UnaryExpression { readonly kind: SyntaxKind.TypeAssertionExpression; readonly type: TypeNode; readonly expression: UnaryExpression; } export interface UnaryExpression extends Expression { _unaryExpressionBrand: any; } export interface UpdateExpression extends UnaryExpression { _updateExpressionBrand: any; } export interface LeftHandSideExpression extends UpdateExpression { _leftHandSideExpressionBrand: any; } export interface MemberExpression extends LeftHandSideExpression { _memberExpressionBrand: any; } export interface PrimaryExpression extends MemberExpression { _primaryExpressionBrand: any; } export interface Declaration extends Node { _declarationBrand: any; symbol: Symbol; } export interface Identifier extends PrimaryExpression, Declaration, JSDocContainer, FlowContainer { readonly kind: SyntaxKind.Identifier; readonly text: string; } export interface LocalsContainer extends Node { _localsContainerBrand: any; } export interface Statement extends Node, JSDocContainer { _statementBrand: any; } export interface Block extends Statement, LocalsContainer { readonly kind: SyntaxKind.Block; readonly statements: NodeArray; } export interface CatchStatement extends Statement, LocalsContainer { readonly kind: SyntaxKind.CatchStatement; readonly parent: Block; readonly expression?: Expression; readonly block: Block; readonly modifier?: Identifier; readonly modifierExpression?: Expression; } export interface CatchExpression extends PrimaryExpression { readonly kind: SyntaxKind.CatchExpression; readonly expression?: Expression; readonly modifier?: Identifier; readonly modifierExpression?: Expression; readonly block?: Block; } export interface NamedDeclaration extends Declaration { readonly name?: DeclarationName; } export type BindingName = Identifier | BindingPattern; export interface VariableDeclaration extends NamedDeclaration, JSDocContainer, PrimaryExpression { readonly kind: SyntaxKind.VariableDeclaration; readonly parent: VariableDeclarationList; readonly refToken?: RefToken; readonly name: BindingName; readonly type?: TypeNode; readonly equalsToken?: Token; readonly initializer?: Expression; } export interface VariableDeclarationList extends Node { readonly kind: SyntaxKind.VariableDeclarationList; readonly parent: VariableStatement | ForStatement | ForEachStatement; readonly declarations: NodeArray; } export interface IterationStatement extends Statement { readonly statement: Statement; } export type ForInitializer = VariableDeclarationList | Expression; export interface ForStatement extends IterationStatement, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.ForStatement; readonly initializer?: ForInitializer; readonly condition?: Expression; readonly incrementor?: Expression; } export interface VariableStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.VariableStatement; readonly modifiers?: NodeArray; readonly declarationList: VariableDeclarationList; readonly type?: TypeNode; } export interface BinaryExpression extends Expression, Declaration, JSDocContainer { readonly kind: SyntaxKind.BinaryExpression; readonly left: Expression; readonly operatorToken: BinaryOperatorToken; readonly right: Expression; } export interface ImpliedStringConcatExpression extends BinaryExpression { } export type FunctionBody = Block; export type ConciseBody = FunctionBody | Expression; export interface ParameterDeclaration extends NamedDeclaration, JSDocContainer { readonly kind: SyntaxKind.Parameter; readonly parent: SignatureDeclaration; readonly modifiers?: NodeArray; readonly dotDotDotToken?: DotDotDotToken; readonly name: BindingName; readonly ampToken?: AmpersandToken | RefToken; readonly type?: TypeNode; readonly initializer?: Expression; } export interface SignatureDeclarationBase extends NamedDeclaration, JSDocContainer { readonly kind: SignatureDeclaration["kind"]; readonly name?: PropertyName; readonly typeParameters?: NodeArray | undefined; readonly parameters: NodeArray; readonly type?: TypeNode | undefined; } /** * 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 | undefined; readonly questionToken?: QuestionToken | undefined; readonly exclamationToken?: ExclamationToken | undefined; readonly body?: Block | Expression | undefined; } export interface FunctionExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.FunctionExpression; readonly modifiers?: NodeArray; readonly name?: Identifier; readonly body: FunctionBody; } export type SignatureDeclaration = CallSignatureDeclaration | MethodSignature | IndexSignatureDeclaration | FunctionTypeNode | JSDocFunctionType | FunctionDeclaration | MethodDeclaration | InlineClosureExpression | FunctionExpression | ArrowFunction; export interface CallSignatureDeclaration extends SignatureDeclarationBase, TypeElement, LocalsContainer { readonly kind: SyntaxKind.CallSignature; } export type DeclarationWithTypeParameterChildren = SignatureDeclaration | ClassLikeDeclaration | StructDeclaration | InterfaceDeclaration | TypeAliasDeclaration | JSDocTemplateTag; export interface TypeParameterDeclaration extends NamedDeclaration, JSDocContainer { readonly kind: SyntaxKind.TypeParameter; readonly parent: DeclarationWithTypeParameterChildren | InferTypeNode; readonly modifiers?: NodeArray; readonly name: Identifier; /** Note: Consider calling `getEffectiveConstraintOfTypeParameter` */ readonly constraint?: TypeNode; readonly default?: TypeNode; expression?: Expression; } export interface DeclarationStatement extends NamedDeclaration, Statement { readonly name?: Identifier | StringLiteral | IntLiteral; } export interface FunctionDeclaration extends FunctionLikeDeclarationBase, DeclarationStatement, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.FunctionDeclaration; readonly modifiers?: NodeArray; readonly name?: Identifier; readonly body?: FunctionBody; } export interface CallExpression extends LeftHandSideExpression, Declaration { readonly kind: SyntaxKind.CallExpression; readonly expression: LeftHandSideExpression; readonly typeArguments?: NodeArray; readonly arguments: NodeArray; } export interface CloneObjectExpression extends PrimaryExpression, Declaration, LeftHandSideExpression { readonly kind: SyntaxKind.CloneObjectExpression; readonly expression: LeftHandSideExpression; readonly arguments?: NodeArray; } export interface MappingLiteralExpression extends PrimaryExpression { readonly kind: SyntaxKind.MappingLiteralExpression; readonly elements: NodeArray; readonly initializer?: Expression; } export interface MappingEntryExpression extends PrimaryExpression { readonly kind: SyntaxKind.MappingEntryExpression; readonly name: Expression; readonly elements: NodeArray; } export interface InlineClosureExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.InlineClosureExpression; readonly modifiers?: NodeArray; readonly body: ConciseBody; readonly name: never; readonly arguments?: NodeArray; } export type LambdaKind = SyntaxKind.LambdaIdentifierExpression | SyntaxKind.LambdaOperatorExpression; export interface LambdaExpression extends PrimaryExpression { readonly kind: LambdaKind; } export interface LambdaIdentifierExpression extends LambdaExpression { readonly kind: SyntaxKind.LambdaIdentifierExpression; readonly name: Expression; } export interface LambdaOperatorExpression extends LambdaExpression { readonly kind: SyntaxKind.LambdaOperatorExpression; readonly operator: LambdaOperatorToken; } export interface ExpressionStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.ExpressionStatement; readonly expression: Expression; } export interface ReturnStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.ReturnStatement; readonly expression?: Expression; } export interface BreakStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.BreakStatement; readonly label?: Identifier; } export interface ContinueStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.ContinueStatement; readonly label?: Identifier; } export type BreakOrContinueStatement = BreakStatement | ContinueStatement; export interface InheritDeclaration extends Statement { readonly kind: SyntaxKind.InheritDeclaration; readonly parent: SourceFile; readonly modifiers?: NodeArray; readonly inheritClause: InheritClauseNodeType; } export type InheritClauseNodeType = StringLiteral | Expression; /** * This is a special type of binary expression where both sides are definitely string literals */ export interface StringConcatExpression extends BinaryExpression { readonly left: StringLiteral; readonly operatorToken: PlusToken; readonly right: StringLiteral; } export interface IfStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.IfStatement; readonly expression: Expression; readonly thenStatement: Statement; readonly elseStatement?: Statement; } export interface EmptyStatement extends Statement { readonly kind: SyntaxKind.EmptyStatement; } export interface SwitchStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.SwitchStatement; readonly expression: Expression; readonly preBlock?: NodeArray; readonly caseBlock: CaseBlock; possiblyExhaustive?: boolean; } export interface CaseBlock extends Node, LocalsContainer { readonly kind: SyntaxKind.CaseBlock; readonly parent: SwitchStatement; readonly clauses: NodeArray; } export interface CaseClause extends Node, JSDocContainer { readonly kind: SyntaxKind.CaseClause; readonly parent: CaseBlock; readonly expression: Expression; readonly statements: NodeArray; } export interface DefaultClause extends Node { readonly kind: SyntaxKind.DefaultClause; readonly parent: CaseBlock; readonly statements: NodeArray; } export type CaseOrDefaultClause = CaseClause | DefaultClause; export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration, JSDocContainer, FlowContainer { readonly kind: SyntaxKind.PropertyAccessExpression; readonly expression: LeftHandSideExpression; readonly name: MemberName | ParenthesizedExpression; readonly propertyAccessToken: PropertyAccessToken; } export interface SuperAccessExpression extends MemberExpression, NamedDeclaration, JSDocContainer, FlowContainer { readonly kind: SyntaxKind.SuperAccessExpression; readonly namespace: Identifier | StringLiteral; readonly name: MemberName; } export interface SuperCall extends CallExpression { readonly expression: SuperAccessExpression; } /** Brand for a PropertyAccessExpression which, like a QualifiedName, consists of a sequence of identifiers separated by dots. */ export interface PropertyAccessEntityNameExpression extends PropertyAccessExpression { _propertyAccessExpressionLikeQualifiedNameBrand?: any; readonly expression: EntityNameExpression; readonly name: Identifier; } export type EntityNameExpression = Identifier | PropertyAccessEntityNameExpression; export type EntityNameOrEntityNameExpression = EntityName | EntityNameExpression; export interface ForStatement extends IterationStatement, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.ForStatement; readonly initializer?: ForInitializer; readonly condition?: Expression; readonly incrementor?: Expression; } export interface ForEachStatement extends IterationStatement, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.ForEachStatement; readonly initializer: ForInitializer; readonly expression: Expression; } export interface DoOrWhileStatementBase extends IterationStatement, LocalsContainer, FlowContainer { readonly expression: Expression; } export interface DoWhileStatement extends DoOrWhileStatementBase { readonly kind: SyntaxKind.DoWhileStatement; } export interface WhileStatement extends DoOrWhileStatementBase { readonly kind: SyntaxKind.WhileStatement; } export type PostfixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken; export interface PostfixUnaryExpression extends UpdateExpression { readonly kind: SyntaxKind.PostfixUnaryExpression; readonly operand: LeftHandSideExpression; readonly operator: PostfixUnaryOperator; } export interface FreshableType extends Type { freshType: FreshableType; regularType: FreshableType; } export interface LiteralType extends FreshableType { value: string | number; } export declare const enum ObjectFlags { None = 0, Class = 1,// Class Interface = 2,// Interface Reference = 4,// Generic type reference Tuple = 8,// Synthesized generic tuple type Anonymous = 16,// Anonymous Mapped = 32,// Mapped Instantiated = 64,// Instantiated anonymous or mapped type ObjectLiteral = 128,// Originates in an object literal EvolvingArray = 256,// Evolving array type ObjectLiteralPatternWithComputedProperties = 512,// Object literal pattern with computed properties ReverseMapped = 1024,// Object contains a property from a reverse-mapped type MappingLiteral = 2048,// Originates in a mapping literal JSLiteral = 4096,// Object type declared in JS - disables errors on read/write of nonexisting members FreshLiteral = 8192,// Fresh object literal ArrayLiteral = 16384,// Type could contain a type variable ClassOrInterface = 3, ContainsSpread = 2097152,// Object literal contains spread operation ObjectRestType = 4194304,// Originates in object rest declaration InstantiationExpressionType = 8388608,// Originates in instantiation expression SingleSignatureType = 134217728 } export interface JSDocParameterTag extends JSDocPropertyLikeTag { readonly kind: SyntaxKind.JSDocParameterTag; } export interface JSDocSignature extends JSDocType, Declaration, JSDocContainer, LocalsContainer { readonly kind: SyntaxKind.JSDocSignature; readonly parameters: readonly JSDocParameterTag[]; readonly type: JSDocReturnTag | undefined; } export interface JSDocReturnTag extends JSDocTag { readonly kind: SyntaxKind.JSDocReturnTag; readonly typeExpression?: JSDocTypeExpression; } export interface IndexType extends InstantiableType { type: InstantiableType | UnionType; } export interface InstantiableType extends Type { } export interface TypeParameter extends InstantiableType { } export interface Signature { declaration?: SignatureDeclaration | JSDocSignature; typeParameters?: readonly TypeParameter[]; parameters: readonly Symbol[]; thisParameter?: Symbol; } export interface UnionOrIntersectionType extends Type { types: Type[]; } export interface UnionType extends UnionOrIntersectionType { } export interface ObjectType extends Type { objectFlags: ObjectFlags; } export interface StructDeclaration extends DeclarationStatement, JSDocContainer, LocalsContainer { readonly kind: SyntaxKind.StructDeclaration; readonly name: Identifier; readonly typeParameters: NodeArray; readonly modifiers?: NodeArray; readonly heritageName?: Identifier; readonly type: TypeNode; } export declare const enum InternalSymbolName { EfunSuperPrefix = "efun", EfunNamespace = "efun::", Call = "__call",// Call signatures Constructor = "__constructor",// Constructor implementations New = "__new",// Constructor signatures Index = "__index",// Index signatures ExportStar = "__export",// Module export * declarations Global = "__global",// Global self-reference Missing = "__missing",// Indicates missing symbol Type = "__type",// Anonymous type literal symbol Object = "__object",// Anonymous object literal declaration Class = "__class",// Unnamed class expression Function = "__function",// Unnamed function expression Computed = "__computed",// Computed property name declaration with dynamic name Resolving = "__resolving__",// Indicator symbol used to mark partially resolved type aliases ExportEquals = "export=",// Export assignment symbol Default = "default",// Default export symbol (technically not wholly internal, but included here for usability) This = "this", InstantiationExpression = "__instantiationExpression",// Instantiation expressions ImportAttributes = "__importAttributes", VarDocTags = "__varDocTags" } export type PrefixUnaryOperator = SyntaxKind.PlusPlusToken | SyntaxKind.MinusMinusToken | SyntaxKind.PlusToken | SyntaxKind.MinusToken | SyntaxKind.TildeToken | SyntaxKind.ExclamationToken | SyntaxKind.LessThanToken | SyntaxKind.DoubleExclamationToken; export interface PrefixUnaryExpression extends UpdateExpression { readonly kind: SyntaxKind.PrefixUnaryExpression; readonly operator: PrefixUnaryOperator; readonly operand: UnaryExpression; } export type AssignmentOperatorToken = Token; export interface AssignmentExpression extends BinaryExpression { readonly left: LeftHandSideExpression; readonly operatorToken: TOperator; } export interface ParenthesizedExpression extends PrimaryExpression, JSDocContainer { readonly kind: SyntaxKind.ParenthesizedExpression; readonly expression: Expression; } export type AssertionExpression = TypeAssertion | CastExpression; export interface ArrayLiteralExpression extends PrimaryExpression { readonly kind: SyntaxKind.ArrayLiteralExpression; readonly elements: NodeArray; } export interface SpreadElement extends Expression { readonly kind: SyntaxKind.SpreadElement; readonly parent: ArrayLiteralExpression | CallExpression | NewExpression; readonly expression: Expression; } export interface ByRefElement extends Expression { readonly kind: SyntaxKind.ByRefElement; readonly parent: CallExpression | NewExpression; readonly expression: Expression; readonly refToken: RefToken | AmpersandToken; } export interface ObjectLiteralElement extends NamedDeclaration { _objectLiteralBrand: any; readonly name?: PropertyName; } export interface PropertyAssignment extends ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.PropertyAssignment; readonly parent: NewExpression; readonly name: PropertyName; readonly initializer: Expression; } export interface ShorthandPropertyAssignment extends ObjectLiteralElement, JSDocContainer { readonly kind: SyntaxKind.ShorthandPropertyAssignment; readonly parent: ObjectLiteralExpression; readonly name: Identifier; readonly equalsToken?: EqualsToken; readonly objectAssignmentInitializer?: Expression; } /** Unlike ObjectLiteralElement, excludes JSXAttribute and JSXSpreadAttribute. */ export type ObjectLiteralElementLike = PropertyAssignment | ShorthandPropertyAssignment | MethodDeclaration; /** * 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.) */ export interface ObjectLiteralExpressionBase extends PrimaryExpression, Declaration { readonly properties: NodeArray; } export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase, JSDocContainer { readonly kind: SyntaxKind.ObjectLiteralExpression; } export type AccessExpression = PropertyAccessExpression | ElementAccessExpression; export interface ElementAccessChain extends ElementAccessExpression { _optionalChainBrand: any; } export interface ElementAccessExpression extends MemberExpression, Declaration, JSDocContainer, FlowContainer { readonly kind: SyntaxKind.ElementAccessExpression; readonly expression: LeftHandSideExpression; readonly argumentExpression: Expression; } export interface RangeExpression extends MemberExpression, Declaration, JSDocContainer, FlowContainer { readonly kind: SyntaxKind.RangeExpression; readonly left: Expression; readonly right: Expression; } export interface CallChain extends CallExpression { _optionalChainBrand: any; } export declare class OperationCanceledException { } export interface CancellationToken { isCancellationRequested(): boolean; /** @throws OperationCanceledException if isCancellationRequested is true */ throwIfCancellationRequested(): void; } export interface NewStructExpression extends PrimaryExpression, Declaration { readonly kind: SyntaxKind.NewStructExpression; readonly type: StructTypeNode; readonly arguments: NodeArray; } export interface EvaluateExpression extends PrimaryExpression { readonly kind: SyntaxKind.EvaluateExpression; readonly expression: Expression; readonly arguments: NodeArray; } export interface NewExpression extends PrimaryExpression, Declaration, LocalsContainer { readonly kind: SyntaxKind.NewExpression; readonly expression?: LeftHandSideExpression | TypeNode | undefined; readonly typeArguments?: NodeArray; readonly arguments?: NodeArray; } export type NewExpressionArgument = Expression | ObjectLiteralElement; export type CallLikeExpression = CallExpression | NewExpression | CloneObjectExpression | InlineClosureExpression; export interface IntrinsicType extends Type { intrinsicName: string; debugIntrinsicName: string | undefined; objectFlags: ObjectFlags; } export type StructuredType = ObjectType | UnionType; export interface ResolvedType extends ObjectType, UnionOrIntersectionType { members: SymbolTable; properties: Symbol[]; callSignatures: readonly Signature[]; constructSignatures: readonly Signature[]; indexInfos: readonly IndexInfo[]; } export interface IndexInfo { keyType: Type; type: Type; isReadonly: boolean; declaration?: IndexSignatureDeclaration; } export interface ClassElement extends NamedDeclaration { _classElementBrand: any; readonly name?: PropertyName; } export interface TypeElement extends NamedDeclaration { _typeElementBrand: any; readonly name?: PropertyName; } export interface TypeLiteralNode extends TypeNode, Declaration { readonly kind: SyntaxKind.TypeLiteral; readonly members: NodeArray; } export type ObjectTypeDeclaration = TypeLiteralNode; export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement, LocalsContainer { readonly kind: SyntaxKind.IndexSignature; readonly parent: ObjectTypeDeclaration; readonly modifiers?: NodeArray; readonly type: TypeNode; } export interface EvaluatorResult { value: T; isSyntacticallyString: boolean; resolvedOtherFiles: boolean; hasExternalReferences: boolean; } export interface JSDocTemplateTag extends JSDocTag { readonly kind: SyntaxKind.JSDocTemplateTag; readonly constraint: JSDocTypeExpression | undefined; readonly typeParameters: NodeArray; } export interface JSDocThisTag extends JSDocTag { readonly kind: SyntaxKind.JSDocThisTag; readonly typeExpression: JSDocTypeExpression; } export interface JSDocVariadicType extends JSDocType { readonly kind: SyntaxKind.JSDocVariadicType; readonly type: TypeNode; } export interface JSDocDeprecatedTag extends JSDocTag { kind: SyntaxKind.JSDocDeprecatedTag; } export interface PropertyDeclaration extends ClassElement, JSDocContainer { readonly kind: SyntaxKind.PropertyDeclaration; readonly parent: StructDeclaration; readonly modifiers?: NodeArray; readonly name: PropertyName; readonly type?: TypeNode; readonly initializer?: Expression; } export interface BindingElement extends NamedDeclaration, FlowContainer { readonly kind: SyntaxKind.BindingElement; readonly parent: BindingPattern; readonly propertyName?: PropertyName; readonly dotDotDotToken?: DotDotDotToken; readonly name: BindingName; readonly initializer?: Expression; } export type BooleanLiteral = TrueLiteral | FalseLiteral; export interface LiteralTypeNode extends TypeNode { readonly kind: SyntaxKind.LiteralType; readonly literal: LiteralExpression | PrefixUnaryExpression | BooleanLiteral | ImpliedStringConcatExpression; } export interface StructTypeNode extends TypeNode { readonly kind: SyntaxKind.StructType; readonly keyword: StructKeywordSyntaxKind; readonly typeName: EntityName; } export declare const enum SymbolFormatFlags { None = 0, WriteTypeParametersOrArguments = 1, UseOnlyExternalAliasing = 2, AllowAnyNodeKind = 4, UseAliasDefinedOutsideCurrentScope = 8 } export interface ArrayBindingPattern extends Node { readonly kind: SyntaxKind.ArrayBindingPattern; readonly parent: VariableDeclaration | ParameterDeclaration | BindingElement; readonly elements: NodeArray; } export type BindingPattern = ArrayBindingPattern; export type ArrayBindingElement = BindingElement | OmittedExpression; export interface IndexedAccessTypeNode extends TypeNode { readonly kind: SyntaxKind.IndexedAccessType; readonly objectType: TypeNode; readonly indexType: TypeNode; } export declare const enum Extension { C = ".c", Lpc = ".lpc", H = ".h", Json = ".json" } export interface SyntaxList extends Node { kind: SyntaxKind.SyntaxList; } export declare const enum LanguageVariant { LDMud = 0, FluffOS = 1, Standard = 2 } export declare const DriverTypeMap: string[]; export declare const enum JSDocParsingMode { /** * Always parse JSDoc comments and include them in the AST. * * This is the default if no mode is provided. */ ParseAll = 0, /** * Never parse JSDoc comments, mo matter the file type. */ ParseNone = 1, /** * Parse only JSDoc comments which are needed to provide correct type errors. * * This will always parse JSDoc in non-TS files, but only parse JSDoc comments * containing `@see` and `@link` in TS files. */ ParseForTypeErrors = 2, /** * Parse only JSDoc comments which are needed to provide correct type info. * * This will always parse JSDoc in non-TS files, but never in TS files. * * Note: Do not use this mode if you require accurate type errors; use {@link ParseForTypeErrors} instead. */ ParseForTypeInfo = 3 } export interface TextSpan { start: number; length: number; } export interface TextChangeRange { span: TextSpan; newLength: number; } export declare const enum IndexKind { String = 0, Number = 1 } export interface StringLiteralType extends LiteralType { value: string; } export interface BytesLiteralType extends LiteralType { value: string; } export interface IntLiteralType extends LiteralType { __intLiteralBrand: any; value: number; } export interface FloatLiteralType extends LiteralType { __floaLiteralBrand: any; value: number; } export type TypeVariable = TypeParameter; export type BaseType = ObjectType | TypeVariable; export interface ScriptReferenceHost { getCompilerOptions(): CompilerOptions; getSourceFile(fileName: string): SourceFile | undefined; getSourceFileByPath(path: Path): SourceFile | undefined; getCurrentDirectory(): string; } export interface Program extends ScriptReferenceHost { getCurrentDirectory(): string; /** * Get a list of root file names that were passed to a 'createProgram' */ getRootFileNames(): readonly string[]; /** * Get a list of files in the program */ getSourceFiles(): readonly SourceFile[]; /** * Get a list of files that are parsable */ getParseableFiles(): ReadonlySet | undefined; /** * Gets a type checker that can be used to semantically analyze source files in the program. */ getTypeChecker(): TypeChecker; getGlobalDiagnostics(cancellationToken?: CancellationToken): readonly Diagnostic[]; getSyntacticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[]; /** The first time this is called, it will return global diagnostics (no location). */ getSemanticDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly Diagnostic[]; getDeclarationDiagnostics(sourceFile?: SourceFile, cancellationToken?: CancellationToken): readonly DiagnosticWithLocation[]; getConfigFileParsingDiagnostics(): readonly Diagnostic[]; getIdentifierCount(): number; getSymbolCount(): number; getTypeCount(): number; getInstantiationCount(): number; getRelationCacheSizes(): { assignable: number; identity: number; subtype: number; strictSubtype: number; }; isSourceFileDefaultLibrary(file: SourceFile): boolean; getProjectReferences(): readonly ProjectReference[] | undefined; getResolvedProjectReferences(): readonly (ResolvedProjectReference | undefined)[] | undefined; } export interface ModuleResolutionHost { fileExists(fileName: string): boolean; readFile(fileName: string): string | undefined; trace?(s: string): void; directoryExists?(directoryName: string): boolean; /** * Resolve a symbolic link. * @see https://nodejs.org/api/fs.html#fs_fs_realpathsync_path_options */ realpath?(path: string): string; getCurrentDirectory?(): string; getDirectories?(path: string): string[]; useCaseSensitiveFileNames?: boolean | (() => boolean) | undefined; } export interface WriteFileCallbackData { } export type WriteFileCallback = (fileName: string, text: string, writeByteOrderMark: boolean, onError?: (message: string) => void, sourceFiles?: readonly SourceFile[], data?: WriteFileCallbackData) => void; export interface CompilerHost extends ModuleResolutionHost { getSourceFile(fileName: string, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined; getSourceFileByPath?(fileName: string, path: Path, languageVersionOrOptions: ScriptTarget | CreateSourceFileOptions, onError?: (message: string) => void, shouldCreateNewSourceFile?: boolean): SourceFile | undefined; getSourceTextFromSnapshot(fileName: string): string | undefined; getCancellationToken?(): CancellationToken; getDefaultLibFileName(options: CompilerOptions): string; getDefaultLibLocation?(): string; writeFile: WriteFileCallback; getCurrentDirectory(): string; getCanonicalFileName(fileName: string): string; useCaseSensitiveFileNames(): boolean; getNewLine(): string; readDirectory?(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): string[]; /** @deprecated supply resolveModuleNameLiterals instead for resolution that can handle newer resolution modes like nodenext */ resolveModuleNames?(moduleNames: string[], containingFile: string, reusedNames: string[] | undefined, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile?: SourceFile): (ResolvedModule | undefined)[]; /** * Returns the module resolution cache used by a provided `resolveModuleNames` implementation so that any non-name module resolution operations (eg, package.json lookup) can reuse it */ getModuleResolutionCache?(): ModuleResolutionCache | undefined; /** * * @param moduleLiterals * @param containingFile * @param redirectedReference * @param options * @param containingSourceFile * @param reusedNames */ resolveModuleNameLiterals?(moduleLiterals: readonly StringLiteral[], containingFile: string, redirectedReference: ResolvedProjectReference | undefined, options: CompilerOptions, containingSourceFile: SourceFile, reusedNames: readonly StringLiteral[] | undefined): readonly ResolvedModuleWithFailedLookupLocations[]; getEnvironmentVariable?(name: string): string | undefined; /** If provided along with custom resolveModuleNames or resolveTypeReferenceDirectives, used to determine if unchanged file path needs to re-resolve modules/type reference directives */ hasInvalidatedResolutions?(filePath: Path): boolean; getParsedCommandLine?(fileName: string): ParsedCommandLine | undefined; jsDocParsingMode?: JSDocParsingMode; } export interface CreateProgramOptions { rootNames: readonly string[]; options: CompilerOptions; projectReferences?: readonly ProjectReference[]; host?: CompilerHost; oldProgram?: Program; configFileParsingDiagnostics?: readonly Diagnostic[]; } export interface GetEffectiveTypeRootsHost { getCurrentDirectory?(): string; } /** * Used by services to specify the minimum host area required to set up source files under any compilation settings */ export interface MinimalResolutionCacheHost extends ModuleResolutionHost { getCompilationSettings(): CompilerOptions; getCompilerHost?(): CompilerHost | undefined; } export declare const enum NewLineKind { CarriageReturnLineFeed = 0, LineFeed = 1 } export interface PrinterOptions { removeComments?: boolean; newLine?: NewLineKind; omitTrailingSemicolon?: boolean; noEmitHelpers?: boolean; } export interface EmitResult { emitSkipped: boolean; /** Contains declaration emit diagnostics */ diagnostics: readonly Diagnostic[]; emittedFiles?: string[]; } export declare enum WatchFileKind { FixedPollingInterval = 0, PriorityPollingInterval = 1, DynamicPriorityPolling = 2, FixedChunkSizePolling = 3, UseFsEvents = 4, UseFsEventsOnParentDirectory = 5 } export declare enum WatchDirectoryKind { UseFsEvents = 0, FixedPollingInterval = 1, DynamicPriorityPolling = 2, FixedChunkSizePolling = 3 } export declare enum PollingWatchKind { FixedInterval = 0, PriorityInterval = 1, DynamicPriority = 2, FixedChunkSize = 3 } export interface WatchOptions { watchFile?: WatchFileKind; watchDirectory?: WatchDirectoryKind; fallbackPolling?: PollingWatchKind; synchronousWatchDirectory?: boolean; excludeDirectories?: string[]; excludeFiles?: string[]; [option: string]: CompilerOptionsValue | undefined; } export declare const enum WatchDirectoryFlags { None = 0, Recursive = 1 } /** * Unique identifier with a package name and version. * If changing this, remember to change `packageIdIsEqual`. */ export interface PackageId { /** * Name of the package. * Should not include `@types`. * If accessing a non-index file, this should include its name e.g. "foo/bar". */ name: string; /** * Name of a submodule within this package. * May be "". */ subModuleName: string; /** Version of the package, e.g. "1.2.3" */ version: string; } export declare const enum ScriptKind { Unknown = 0, LPC = 1, 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 } export declare const enum ScriptTarget { LPC = 1, JavaScript = 2, JSON = 3, Latest = 1 } export declare enum ModuleKind { None = 0, LPC = 1 } export declare enum ModuleResolutionKind { Classic = 1 } export type ResolutionMode = ModuleKind.LPC | undefined; export declare const enum NodeBuilderFlags { None = 0, NoTruncation = 1,// Don't truncate result WriteArrayAsGenericType = 2,// Write Array instead T[] GenerateNamesForShadowedTypeParams = 4,// When a type parameter T is shadowing another T, generate a name for it so it can still be referenced UseStructuralFallback = 8,// When an alias cannot be named by its symbol, rather than report an error, fallback to a structural printout if possible ForbidIndexedAccessSymbolReferences = 16,// Forbid references like `I["a"]["b"]` - print `typeof I.a.b` instead WriteTypeArgumentsOfSignature = 32,// Write the type arguments instead of type parameters of the signature UseFullyQualifiedType = 64,// Write out the fully qualified type name (eg. Module.Type, instead of Type) UseOnlyExternalAliasing = 128,// Only use external aliases for a symbol SuppressAnyReturnType = 256,// If the return type is any-like and can be elided, don't offer a return type. WriteTypeParametersInQualifiedName = 512, MultilineObjectLiterals = 1024,// Always write object literals across multiple lines WriteClassExpressionAsTypeLiteral = 2048,// Write class {} as { new(): {} } - used for mixin declaration emit UseTypeOfFunction = 4096,// Build using typeof instead of function type literal OmitParameterModifiers = 8192,// Omit modifiers on parameters UseAliasDefinedOutsideCurrentScope = 16384,// Allow non-visible aliases UseSingleQuotesForStringLiteralType = 268435456,// Use single quotes for string literal type NoTypeReduction = 536870912,// Don't call getReducedType OmitThisParameter = 33554432, AllowThisInObjectLiteral = 32768, AllowQualifiedNameInPlaceOfIdentifier = 65536, AllowAnonymousIdentifier = 131072, AllowEmptyUnionOrIntersection = 262144, AllowEmptyTuple = 524288, AllowUniqueESSymbolType = 1048576, AllowEmptyIndexInfoType = 2097152, AllowNodeModulesRelativePaths = 67108864, IgnoreErrors = 70221824, InObjectTypeLiteral = 4194304, InTypeAlias = 8388608,// Writing type in type alias declaration InInitialEntityName = 16777216 } export interface ComputedPropertyName extends Node { readonly kind: SyntaxKind.ComputedPropertyName; readonly parent: Declaration; readonly expression: Expression; } export type ModuleExportName = Identifier | StringLiteral; export interface QualifiedName extends Node, FlowContainer { readonly kind: SyntaxKind.QualifiedName; readonly left: EntityName; readonly right: Identifier; } export interface MappedTypeNode extends TypeNode, Declaration, LocalsContainer { readonly kind: SyntaxKind.MappedType; readonly readonlyToken?: PlusToken | MinusToken; readonly typeParameter: TypeParameterDeclaration; readonly nameType?: TypeNode; readonly type?: TypeNode; /** Used only to produce grammar errors */ readonly members?: NodeArray; } export declare const enum EmitHint { SourceFile = 0,// Emitting a SourceFile Expression = 1,// Emitting an Expression IdentifierName = 2,// Emitting an IdentifierName MappedTypeParameter = 3,// Emitting a TypeParameterDeclaration inside of a MappedTypeNode Unspecified = 4,// Emitting an otherwise unspecified node EmbeddedStatement = 5,// Emitting an embedded statement JsxAttributeValue = 6,// Emitting a JSX attribute value ImportTypeNodeAttributes = 7 } export declare const enum ListFormat { None = 0, SingleLine = 0,// Prints the list on a single line (default). MultiLine = 1,// Prints the list on multiple lines. PreserveLines = 2,// Prints the list using line preservation if possible. LinesMask = 3, NotDelimited = 0,// There is no delimiter between list items (default). BarDelimited = 4,// Each list item is space-and-bar (" |") delimited. AmpersandDelimited = 8,// Each list item is space-and-ampersand (" &") delimited. CommaDelimited = 16,// Each list item is comma (",") delimited. AsteriskDelimited = 32,// Each list item is asterisk ("\n *") delimited, used with JSDoc. DelimitersMask = 60, AllowTrailingComma = 64,// Write a trailing comma (",") if present. Indented = 128,// The list should be indented. SpaceBetweenBraces = 256,// Inserts a space after the opening brace and before the closing brace. SpaceBetweenSiblings = 512,// Inserts a space between each sibling node. Braces = 1024,// The list is surrounded by "{" and "}". Parenthesis = 2048,// The list is surrounded by "(" and ")". AngleBrackets = 4096,// The list is surrounded by "<" and ">". SquareBrackets = 8192,// The list is surrounded by "[" and "]". ArrayBrackets = 4194304,// The list is surrounded by "({" and "})". BracketsMask = 4209664, OptionalIfUndefined = 16384,// Do not emit brackets if the list is undefined. OptionalIfEmpty = 32768,// Do not emit brackets if the list is empty. Optional = 49152, PreferNewLine = 65536,// Prefer adding a LineTerminator between synthesized nodes. NoTrailingNewLine = 131072,// Do not emit a trailing NewLine for a MultiLine list. NoInterveningComments = 262144,// Do not emit comments between each node NoSpaceIfEmpty = 524288,// If the literal is empty, do not add spaces between braces. SingleElement = 1048576, SpaceAfterList = 2097152,// Add space after list Modifiers = 2359808, HeritageClauses = 512, SingleLineTypeLiteralMembers = 768, MultiLineTypeLiteralMembers = 32897, SingleLineTupleTypeElements = 528, MultiLineTupleTypeElements = 657, UnionTypeConstituents = 516, IntersectionTypeConstituents = 520, ObjectBindingPatternElements = 525136, ArrayBindingPatternElements = 524880, ObjectLiteralExpressionProperties = 526226, ImportAttributes = 526226, /** @deprecated */ ImportClauseEntries = 526226, ArrayLiteralExpressionElements = 4195026, JsArrayLiteralExpressionElements = 8914, CommaListElements = 528, CallExpressionArguments = 2576, NewExpressionArguments = 18960, TemplateExpressionSpans = 262144, SingleLineBlockStatements = 768, MultiLineBlockStatements = 129, VariableDeclarationList = 528, SingleLineFunctionBodyStatements = 768, MultiLineFunctionBodyStatements = 1, ClassHeritageClauses = 0, ClassMembers = 129, InterfaceMembers = 129, EnumMembers = 145, CaseBlockClauses = 129, NamedImportsOrExportsElements = 525136, JsxElementOrFragmentChildren = 262144, JsxElementAttributes = 262656, CaseOrDefaultClauseStatements = 163969, HeritageClauseTypes = 528, SourceFileStatements = 131073, Decorators = 2146305, TypeArguments = 53776, TypeParameters = 53776, Parameters = 2576, IndexSignatureParameters = 8848, JSDocComment = 33 } export interface Bundle extends Node { readonly kind: SyntaxKind.Bundle; readonly sourceFiles: readonly SourceFile[]; } export interface Printer { /** * Print a node and its subtree as-is, without any emit transformations. * @param hint A value indicating the purpose of a node. This is primarily used to * distinguish between an `Identifier` used in an expression position, versus an * `Identifier` used as an `IdentifierName` as part of a declaration. For most nodes you * should just pass `Unspecified`. * @param node The node to print. The node and its subtree are printed as-is, without any * emit transformations. * @param sourceFile A source file that provides context for the node. The source text of * the file is used to emit the original source content for literals and identifiers, while * the identifiers of the source file are used when generating unique names to avoid * collisions. */ printNode(hint: EmitHint, node: Node, sourceFile: SourceFile): string; /** * Prints a list of nodes using the given format flags */ printList(format: ListFormat, list: NodeArray, sourceFile: SourceFile): string; /** * Prints a source file as-is, without any emit transformations. */ printFile(sourceFile: SourceFile): string; /** * Prints a bundle of source files as-is, without any emit transformations. */ printBundle(bundle: Bundle): string; } export interface PrintHandlers { /** * A hook used by the Printer when generating unique names to avoid collisions with * globally defined names that exist outside of the current source file. */ hasGlobalName?(name: string): boolean; /** * A hook used by the Printer to provide notifications prior to emitting a node. A * compatible implementation **must** invoke `emitCallback` with the provided `hint` and * `node` values. * @param hint A hint indicating the intended purpose of the node. * @param node The node to emit. * @param emitCallback A callback that, when invoked, will emit the node. * @example * ```ts * var printer = createPrinter(printerOptions, { * onEmitNode(hint, node, emitCallback) { * // set up or track state prior to emitting the node... * emitCallback(hint, node); * // restore state after emitting the node... * } * }); * ``` */ onEmitNode?(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void; /** * A hook used to check if an emit notification is required for a node. * @param node The node to emit. */ isEmitNotificationEnabled?(node: Node): boolean; /** * A hook used by the Printer to perform just-in-time substitution of a node. This is * primarily used by node transformations that need to substitute one node for another, * such as replacing `myExportedVar` with `exports.myExportedVar`. * @param hint A hint indicating the intended purpose of the node. * @param node The node to emit. * @example * ```ts * var printer = createPrinter(printerOptions, { * substituteNode(hint, node) { * // perform substitution if necessary... * return node; * } * }); * ``` */ substituteNode?(hint: EmitHint, node: Node): Node; } export interface SourceMapSource { fileName: string; text: string; skipTrivia?: (pos: number) => number; } /** * A list of comma-separated expressions. This node is only created by transformations. */ export interface CommaListExpression extends Expression { readonly kind: SyntaxKind.CommaListExpression; readonly elements: NodeArray; } export interface ParenthesizedTypeNode extends TypeNode { readonly kind: SyntaxKind.ParenthesizedType; readonly type: TypeNode; } export type VariableLikeDeclaration = VariableDeclaration | ParameterDeclaration | BindingElement | PropertyDeclaration | PropertyAssignment | ShorthandPropertyAssignment | JSDocPropertyTag | JSDocParameterTag; /** Class and interface types (ObjectFlags.Class and ObjectFlags.Interface). */ export interface InterfaceType extends ObjectType { typeParameters: TypeParameter[] | undefined; outerTypeParameters: TypeParameter[] | undefined; localTypeParameters: TypeParameter[] | undefined; thisType: TypeParameter | undefined; } export interface HeritageClause extends Node { readonly kind: SyntaxKind.HeritageClause; readonly parent: StructDeclaration | ClassLikeDeclaration; readonly types: NodeArray; } export interface GenericType extends InterfaceType, TypeReference { } /** * Type references (ObjectFlags.Reference). When a class or interface has type parameters or * a "this" type, references to the class or interface are made using type references. The * typeArguments property specifies the types to substitute for the type parameters of the * class or interface and optionally includes an extra element that specifies the type to * substitute for "this" in the resulting instantiation. When no extra argument is present, * the type reference itself is substituted for "this". The typeArguments property is undefined * if the class or interface has no type parameters and the reference isn't specifying an * explicit "this" argument. */ export interface TypeReference extends ObjectType { target: GenericType; node?: TypeReferenceNode | ArrayTypeNode | TupleTypeNode; } export type TypeReferenceType = TypeReferenceNode | StructTypeNode | ExpressionWithTypeArguments; export interface FunctionOrConstructorTypeNodeBase extends TypeNode, SignatureDeclarationBase { readonly kind: SyntaxKind.FunctionType; readonly type: TypeNode; } export interface FunctionTypeNode extends FunctionOrConstructorTypeNodeBase, LocalsContainer { readonly kind: SyntaxKind.FunctionType; } export interface NodeWithTypeArguments extends TypeNode { readonly typeArguments?: NodeArray; } export interface TypeReferenceNode extends NodeWithTypeArguments { readonly kind: SyntaxKind.TypeReference; readonly typeName: EntityName; } export declare const enum InferencePriority { None = 0, NakedTypeVariable = 1,// Naked type variable in union or intersection type SpeculativeTuple = 2,// Speculative tuple inference SubstituteSource = 4,// Source of inference originated within a substitution type's substitute HomomorphicMappedType = 8,// Reverse inference for homomorphic mapped type PartialHomomorphicMappedType = 16,// Partial reverse inference for homomorphic mapped type MappedTypeConstraint = 32,// Reverse inference for mapped type ContravariantConditional = 64,// Conditional type in contravariant position ReturnType = 128,// Inference made from return type of generic function LiteralKeyof = 256,// Inference made from a string literal to a keyof T NoConstraints = 512,// Don't infer from constraints of instantiable types AlwaysStrict = 1024,// Always use strict rules for contravariant inferences MaxValue = 2048,// Seed for inference priority tracking PriorityImpliesCombination = 416,// These priorities imply that the resulting type should be a combination of all candidates Circularity = -1 } export interface InferTypeNode extends TypeNode { readonly kind: SyntaxKind.InferType; readonly typeParameter: TypeParameterDeclaration; } export interface DeferredTypeReference extends TypeReference { } export interface SubstitutionType extends InstantiableType { objectFlags: ObjectFlags; baseType: Type; constraint: Type; } export interface StringMappingType extends InstantiableType { symbol: Symbol; type: Type; } export interface SynthesizedComment extends CommentRange { text: string; pos: -1; end: -1; hasLeadingNewline?: boolean; } export type VisitResult = T | readonly Node[]; /** * A function that accepts and possibly transforms a node. */ export type Visitor = (node: TIn) => VisitResult; export interface CoreTransformationContext { readonly factory: NodeFactory; /** Gets the compiler options supplied to the transformer. */ getCompilerOptions(): CompilerOptions; /** Starts a new lexical environment. */ startLexicalEnvironment(): void; /** Suspends the current lexical environment, usually after visiting a parameter list. */ suspendLexicalEnvironment(): void; /** Resumes a suspended lexical environment, usually before visiting a function body. */ resumeLexicalEnvironment(): void; /** Ends a lexical environment, returning any declarations. */ endLexicalEnvironment(): Statement[] | undefined; /** Hoists a function declaration to the containing scope. */ hoistFunctionDeclaration(node: FunctionDeclaration): void; /** Hoists a variable declaration to the containing scope. */ hoistVariableDeclaration(node: Identifier): void; } export type EmitHelperUniqueNameCallback = (name: string) => string; export interface EmitHelperBase { readonly name: string; readonly scoped: boolean; readonly text: string | ((node: EmitHelperUniqueNameCallback) => string); readonly priority?: number; readonly dependencies?: EmitHelper[]; } export interface ScopedEmitHelper extends EmitHelperBase { readonly scoped: true; } export interface UnscopedEmitHelper extends EmitHelperBase { readonly scoped: false; readonly text: string; } export type EmitHelper = ScopedEmitHelper | UnscopedEmitHelper; export interface TransformationContext extends CoreTransformationContext { /** Gets and resets the requested non-scoped emit helpers. */ readEmitHelpers(): EmitHelper[] | undefined; /** Enables expression substitutions in the pretty printer for the provided SyntaxKind. */ enableSubstitution(kind: SyntaxKind): void; /** Determines whether expression substitutions are enabled for the provided node. */ isSubstitutionEnabled(node: Node): boolean; /** * Hook used by transformers to substitute expressions just before they * are emitted by the pretty printer. * * NOTE: Transformation hooks should only be modified during `Transformer` initialization, * before returning the `NodeTransformer` callback. */ onSubstituteNode: (hint: EmitHint, node: Node) => Node; /** * Enables before/after emit notifications in the pretty printer for the provided * SyntaxKind. */ enableEmitNotification(kind: SyntaxKind): void; /** * Determines whether before/after emit notifications should be raised in the pretty * printer when it emits a node. */ isEmitNotificationEnabled(node: Node): boolean; /** * Hook used to allow transformers to capture state before or after * the printer emits a node. * * NOTE: Transformation hooks should only be modified during `Transformer` initialization, * before returning the `NodeTransformer` callback. */ onEmitNode: (hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void) => void; } /** * A function that walks a node array using the given visitor, returning an array whose contents satisfy the test. * * - If the input node array is undefined, the output is undefined. * - If the visitor can return undefined, the node it visits in the array will be reused. * - If the output node array is not undefined, then its contents will satisfy the test. * - In order to obtain a return type that is more specific than `NodeArray`, a test * function _must_ be provided, and that function must be a type predicate. * * For the canonical implementation of this type, @see {visitNodes}. */ export interface NodesVisitor { | undefined, TOut extends Node>(nodes: TInArray, visitor: Visitor, test: (node: Node) => node is TOut, start?: number, count?: number): NodeArray | (TInArray & undefined); | undefined>(nodes: TInArray, visitor: Visitor, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray | (TInArray & undefined); } export declare const enum GeneratedIdentifierFlags { None = 0,// Mask to extract the kind of identifier from its flags. ReservedInNestedScopes = 8,// Reserve the generated name in nested scopes Optimistic = 16,// First instance won't use '_#' if there's no conflict FileLevel = 32,// Use only the file identifiers list and not generated names to search for conflicts AllowNameSubstitution = 64 } export interface EvolvingArrayType extends ObjectType { elementType: Type; finalArrayType?: Type; } export interface InterfaceTypeWithDeclaredMembers extends InterfaceType { declaredProperties: Symbol[]; declaredCallSignatures: Signature[]; declaredConstructSignatures: Signature[]; declaredIndexInfos: IndexInfo[]; } export interface IntersectionType extends UnionOrIntersectionType { } export interface ParseConfigHost extends ModuleResolutionHost { useCaseSensitiveFileNames: boolean; readDirectory(rootDir: string, extensions: readonly string[], excludes: readonly string[] | undefined, includes: readonly string[], depth?: number): readonly 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 | undefined; trace?(s: string): void; } export interface FileExtensionInfo { extension: string; isMixedContent: boolean; scriptKind?: ScriptKind; } export type LpcLoadImportResult = { filename: string; source?: string; error?: string; }; export interface LpcFileHandler extends IFileHandler { loadIncludeFile(sourceFilename: string, filename: string, localFirst: boolean, additionalSearchDirs?: string[]): LpcLoadImportResult; loadInclude(sourceFilename: string, filename: string): LoadImportResult; } export interface TransformationResult { /** Gets the transformed source files. */ transformed: T[]; /** Gets diagnostics for the transformation. */ diagnostics?: DiagnosticWithLocation[]; /** * Gets a substitute for a node, if one is available; otherwise, returns the original node. * * @param hint A hint as to the intended usage of the node. * @param node The node to substitute. */ substituteNode(hint: EmitHint, node: Node): Node; /** * Emits a node with possible notification. * * @param hint A hint as to the intended usage of the node. * @param node The node to emit. * @param emitCallback A callback used to emit the node. */ emitNodeWithNotification(hint: EmitHint, node: Node, emitCallback: (hint: EmitHint, node: Node) => void): void; /** * Indicates if a given node needs an emit notification * * @param node The node to emit. */ isEmitNotificationEnabled?(node: Node): boolean; /** * Clean up EmitNode entries on any parse-tree nodes. */ dispose(): void; } /** * A function that is used to initialize and return a `Transformer` callback, which in turn * will be used to transform one or more nodes. */ export type TransformerFactory = (context: TransformationContext) => Transformer; /** * A function that transforms a node. */ export type Transformer = (node: T) => T; export interface PropertyAccessChain extends PropertyAccessExpression { _optionalChainBrand: any; readonly name: MemberName; } export type OptionalChain = PropertyAccessChain | ElementAccessChain | CallChain; export interface ExportDeclaration extends DeclarationStatement, JSDocContainer { readonly kind: SyntaxKind.ExportDeclaration; readonly parent: SourceFile; readonly modifiers?: NodeArray; readonly isTypeOnly: boolean; /** If this is not a StringLiteral it will be a grammar error. */ readonly moduleSpecifier?: Expression; readonly attributes?: ImportAttributes; } export interface CommentDirective { range: TextRange; type: CommentDirectiveType; } export interface LabeledStatement extends Statement, FlowContainer { readonly kind: SyntaxKind.LabeledStatement; readonly label: Identifier; readonly statement: Statement; } export interface PropertySignature extends TypeElement, JSDocContainer { readonly kind: SyntaxKind.PropertySignature; readonly parent: TypeLiteralNode; readonly modifiers?: NodeArray; readonly name: PropertyName; readonly type?: TypeNode; } /** * A function that walks a node using the given visitor, lifting node arrays into single nodes, * returning an node which satisfies the test. * * - If the input node is undefined, then the output is undefined. * - If the visitor returns undefined, then the output is undefined. * - If the output node is not undefined, then it will satisfy the test function. * - In order to obtain a return type that is more specific than `Node`, a test * function _must_ be provided, and that function must be a type predicate. * * For the canonical implementation of this type, @see {visitNode}. */ export interface NodeVisitor { (node: TIn, visitor: Visitor, TVisited>, test: (node: Node) => node is TOut, lift?: (node: readonly Node[]) => Node): TOut | (TIn & undefined) | (TVisited & undefined); (node: TIn, visitor: Visitor, TVisited>, test?: (node: Node) => boolean, lift?: (node: readonly Node[]) => Node): Node | (TIn & undefined) | (TVisited & undefined); } export interface UserPreferences { readonly disableSuggestions?: boolean; readonly quotePreference?: "auto" | "double" | "single"; /** * If enabled, TypeScript will search through all external modules' exports and add them to the completions list. * This affects lone identifier completions but not completions on the right hand side of `obj.`. */ readonly includeCompletionsForModuleExports?: boolean; /** * Enables auto-import-style completions on partially-typed import statements. E.g., allows * `import write|` to be completed to `import { writeFile } from "fs"`. */ readonly includeCompletionsForImportStatements?: boolean; /** * Allows completions to be formatted with snippet text, indicated by `CompletionItem["isSnippet"]`. */ readonly includeCompletionsWithSnippetText?: boolean; /** * Unless this option is `false`, or `includeCompletionsWithInsertText` is not enabled, * member completion lists triggered with `.` will include entries on potentially-null and potentially-undefined * values, with insertion text to replace preceding `.` tokens with `?.`. */ readonly includeAutomaticOptionalChainCompletions?: boolean; /** * If enabled, the completion list will include completions with invalid identifier names. * For those entries, The `insertText` and `replacementSpan` properties will be set to change from `.x` property access to `["x"]`. */ readonly includeCompletionsWithInsertText?: boolean; /** * If enabled, completions for class members (e.g. methods and properties) will include * a whole declaration for the member. * E.g., `class A { f| }` could be completed to `class A { foo(): number {} }`, instead of * `class A { foo }`. */ readonly includeCompletionsWithClassMemberSnippets?: boolean; /** * If enabled, object literal methods will have a method declaration completion entry in addition * to the regular completion entry containing just the method name. * E.g., `const objectLiteral: T = { f| }` could be completed to `const objectLiteral: T = { foo(): void {} }`, * in addition to `const objectLiteral: T = { foo }`. */ readonly includeCompletionsWithObjectLiteralMethodSnippets?: boolean; /** * Indicates whether {@link CompletionEntry.labelDetails completion entry label details} are supported. * If not, contents of `labelDetails` may be included in the {@link CompletionEntry.name} property. */ readonly useLabelDetailsInCompletionEntries?: boolean; readonly allowIncompleteCompletions?: boolean; readonly importModuleSpecifierPreference?: "shortest" | "project-relative" | "relative" | "non-relative"; /** Determines whether we import `foo/index.ts` as "foo", "foo/index", or "foo/index.js" */ readonly importModuleSpecifierEnding?: "auto" | "minimal" | "index" | "js"; readonly allowTextChangesInNewFiles?: boolean; readonly providePrefixAndSuffixTextForRename?: boolean; readonly includePackageJsonAutoImports?: "auto" | "on" | "off"; readonly provideRefactorNotApplicableReason?: boolean; readonly jsxAttributeCompletionStyle?: "auto" | "braces" | "none"; readonly includeInlayParameterNameHints?: "none" | "literals" | "all"; readonly includeInlayParameterNameHintsWhenArgumentMatchesName?: boolean; readonly includeInlayFunctionParameterTypeHints?: boolean; readonly includeInlayVariableTypeHints?: boolean; readonly includeInlayVariableTypeHintsWhenTypeMatchesName?: boolean; readonly includeInlayPropertyDeclarationTypeHints?: boolean; readonly includeInlayFunctionLikeReturnTypeHints?: boolean; readonly includeInlayEnumMemberValueHints?: boolean; readonly interactiveInlayHints?: boolean; readonly allowRenameOfImportPath?: boolean; readonly autoImportFileExcludePatterns?: string[]; readonly preferTypeOnlyAutoImports?: boolean; /** * Indicates whether imports should be organized in a case-insensitive manner. */ readonly organizeImportsIgnoreCase?: "auto" | boolean; /** * Indicates whether imports should be organized via an "ordinal" (binary) comparison using the numeric value * of their code points, or via "unicode" collation (via the * [Unicode Collation Algorithm](https://unicode.org/reports/tr10/#Scope)) using rules associated with the locale * specified in {@link organizeImportsCollationLocale}. * * Default: `"ordinal"`. */ readonly organizeImportsCollation?: "ordinal" | "unicode"; /** * Indicates the locale to use for "unicode" collation. If not specified, the locale `"en"` is used as an invariant * for the sake of consistent sorting. Use `"auto"` to use the detected UI locale. * * This preference is ignored if {@link organizeImportsCollation} is not `"unicode"`. * * Default: `"en"` */ readonly organizeImportsLocale?: string; /** * Indicates whether numeric collation should be used for digit sequences in strings. When `true`, will collate * strings such that `a1z < a2z < a100z`. When `false`, will collate strings such that `a1z < a100z < a2z`. * * This preference is ignored if {@link organizeImportsCollation} is not `"unicode"`. * * Default: `false` */ readonly organizeImportsNumericCollation?: boolean; /** * Indicates whether accents and other diacritic marks are considered unequal for the purpose of collation. When * `true`, characters with accents and other diacritics will be collated in the order defined by the locale specified * in {@link organizeImportsCollationLocale}. * * This preference is ignored if {@link organizeImportsCollation} is not `"unicode"`. * * Default: `true` */ readonly organizeImportsAccentCollation?: boolean; /** * Indicates whether upper case or lower case should sort first. When `false`, the default order for the locale * specified in {@link organizeImportsCollationLocale} is used. * * This preference is ignored if {@link organizeImportsCollation} is not `"unicode"`. This preference is also * ignored if we are using case-insensitive sorting, which occurs when {@link organizeImportsIgnoreCase} is `true`, * or if {@link organizeImportsIgnoreCase} is `"auto"` and the auto-detected case sensitivity is determined to be * case-insensitive. * * Default: `false` */ readonly organizeImportsCaseFirst?: "upper" | "lower" | false; /** * Indicates where named type-only imports should sort. "inline" sorts named imports without regard to if the import is * type-only. * * Default: `last` */ readonly organizeImportsTypeOrder?: OrganizeImportsTypeOrder; /** * Indicates whether to exclude standard library and node_modules file symbols from navTo results. */ readonly excludeLibrarySymbolsInNavTo?: boolean; readonly lazyConfiguredProjectsFromExternalProject?: boolean; readonly displayPartsForJSDoc?: boolean; readonly generateReturnInDocTemplate?: boolean; readonly disableLineTextInReferences?: boolean; } export type OrganizeImportsTypeOrder = "last" | "inline" | "first"; export interface JSDocLink extends Node { readonly kind: SyntaxKind.JSDocLink; readonly name?: EntityName | JSDocMemberName; text: string; } export interface JSDocLinkCode extends Node { readonly kind: SyntaxKind.JSDocLinkCode; readonly name?: EntityName | JSDocMemberName; text: string; } export interface JSDocLinkPlain extends Node { readonly kind: SyntaxKind.JSDocLinkPlain; readonly name?: EntityName | JSDocMemberName; text: string; } export interface JSDocOverloadTag extends JSDocTag { readonly kind: SyntaxKind.JSDocOverloadTag; readonly parent: JSDoc; readonly typeExpression: JSDocSignature; } /** * Note that `@extends` is a synonym of `@augments`. * Both tags are represented by this interface. */ export interface JSDocAugmentsTag extends JSDocTag { readonly kind: SyntaxKind.JSDocAugmentsTag; readonly class: Expression & { readonly expression: Identifier | PropertyAccessEntityNameExpression; }; } export interface JSDocImplementsTag extends JSDocTag { readonly kind: SyntaxKind.JSDocImplementsTag; readonly class: Expression & { readonly expression: Identifier | PropertyAccessEntityNameExpression; }; } export interface JSDocCallbackTag extends JSDocTag, NamedDeclaration, LocalsContainer { readonly kind: SyntaxKind.JSDocCallbackTag; readonly parent: JSDoc; readonly fullName?: Identifier; readonly name?: Identifier; readonly typeExpression: JSDocSignature; } export interface JSDocPropertyTag extends JSDocPropertyLikeTag { readonly kind: SyntaxKind.JSDocPropertyTag; } export interface JSDocVariableTag extends JSDocPropertyLikeTag { readonly kind: SyntaxKind.JSDocVariableTag; } export interface JSDocSatisfiesTag extends JSDocTag { readonly kind: SyntaxKind.JSDocSatisfiesTag; readonly typeExpression: JSDocTypeExpression; } export interface JSDocNameReference extends Node { readonly kind: SyntaxKind.JSDocNameReference; readonly name: EntityName | JSDocMemberName; } export interface JSDocSeeTag extends JSDocTag { readonly kind: SyntaxKind.JSDocSeeTag; readonly name?: JSDocNameReference; } export interface JSDocAuthorTag extends JSDocTag { readonly kind: SyntaxKind.JSDocAuthorTag; } export interface JSDocThrowsTag extends JSDocTag { readonly kind: SyntaxKind.JSDocThrowsTag; readonly typeExpression?: JSDocTypeExpression; } export interface JSDocTypeTag extends JSDocTag { readonly kind: SyntaxKind.JSDocTypeTag; readonly typeExpression: JSDocTypeExpression; } export interface MethodDeclaration extends FunctionLikeDeclarationBase, ClassElement, ObjectLiteralElement, JSDocContainer, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.MethodDeclaration; readonly parent: ObjectLiteralExpression; readonly modifiers?: NodeArray | undefined; readonly name: PropertyName; readonly body?: FunctionBody | undefined; } export interface MethodSignature extends SignatureDeclarationBase, TypeElement, LocalsContainer { readonly kind: SyntaxKind.MethodSignature; readonly parent: TypeLiteralNode | InterfaceDeclaration; readonly modifiers?: NodeArray; readonly name: PropertyName; } export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer { readonly kind: SyntaxKind.ArrowFunction; readonly modifiers?: NodeArray; readonly equalsGreaterThanToken: EqualsGreaterThanToken; readonly body: ConciseBody; readonly name: never; } export interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression { readonly kind: SyntaxKind.ClassExpression; readonly modifiers?: NodeArray; } export interface PreprocessorDirective extends Statement { kind: DirectiveSyntaxKind; } export interface PragmaDirective extends PreprocessorDirective { kind: SyntaxKind.PragmaDirective; expression: NodeArray; } export interface IncludeDirective extends PreprocessorDirective, SourceFileBase { kind: SyntaxKind.IncludeDirective; content: NodeArray; readonly fileName: string; readonly localFirst: boolean; readonly statements: NodeArray; readonly endOfFileToken: Token; readonly text: string; inactiveCodeRanges?: readonly TextRange[]; } export interface DefineDirective extends PreprocessorDirective, Declaration { kind: SyntaxKind.DefineDirective; name: Identifier; arguments?: NodeArray; range: TextRange; } export interface MacroParameter extends ReadonlyTextRange, MacroIncludedFileRange { disabled?: boolean; /** get the sourcetext that contains the arg value range */ text: string; } export interface PositionState { pos: number; tokenStart: number; fileName: string; macro: Macro; include: IncludeDirective; stateId: number; } export interface Macro extends MacroIncludedFileRange { directive: DefineDirective; name: string; isBuiltIn: boolean; includeDirPos?: number; includeDirEnd?: number; includeFilename?: string; disabled?: boolean; /** get the sourcetext that contains the macro definition range */ getText(): string; range: TextRange; arguments?: NodeArray; argsIn?: MapLike; pos?: PositionState; end?: number; } export interface UndefDirective extends PreprocessorDirective { kind: SyntaxKind.UndefDirective; name: Identifier; } export interface ClassLikeDeclarationBase extends NamedDeclaration, JSDocContainer { readonly kind: SyntaxKind.ClassDeclaration | SyntaxKind.ClassExpression; readonly name?: Identifier; readonly typeParameters?: NodeArray; readonly members: NodeArray; } export interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement { readonly kind: SyntaxKind.ClassDeclaration; readonly modifiers?: NodeArray; /** May be undefined in `export default class { ... }`. */ readonly name?: Identifier; } export type ClassLikeDeclaration = ClassDeclaration | ClassExpression; export interface MissingDeclaration extends DeclarationStatement, PrimaryExpression { readonly kind: SyntaxKind.MissingDeclaration; readonly name?: Identifier; } export interface TypeAliasDeclaration extends DeclarationStatement, JSDocContainer, LocalsContainer { readonly kind: SyntaxKind.TypeAliasDeclaration; readonly modifiers?: NodeArray; readonly name: Identifier; readonly typeParameters?: NodeArray; readonly type: TypeNode; } export interface SyntheticExpression extends Expression { readonly kind: SyntaxKind.SyntheticExpression; readonly isSpread: boolean; readonly type: Type; readonly tupleNameSource?: ParameterDeclaration | NamedTupleMember; } export interface IndexedAccessType extends InstantiableType { objectType: Type; indexType: Type; constraint?: Type; simplifiedForReading?: Type; simplifiedForWriting?: Type; } export type UnionOrIntersectionTypeNode = UnionTypeNode; export declare const enum TypePredicateKind { This = 0, Identifier = 1, AssertsThis = 2, AssertsIdentifier = 3 } export interface TypePredicateBase { kind: TypePredicateKind; type: Type | undefined; } export interface IdentifierTypePredicate extends TypePredicateBase { kind: TypePredicateKind.Identifier; parameterName: string; parameterIndex: number; type: Type; } export interface AssertsThisTypePredicate extends TypePredicateBase { kind: TypePredicateKind.AssertsThis; parameterName: undefined; parameterIndex: undefined; type: Type | undefined; } export interface AssertsIdentifierTypePredicate extends TypePredicateBase { kind: TypePredicateKind.AssertsIdentifier; parameterName: string; parameterIndex: number; type: Type | undefined; } export type TypePredicate = IdentifierTypePredicate | AssertsThisTypePredicate | AssertsIdentifierTypePredicate; export interface ExpressionWithTypeArguments extends MemberExpression, NodeWithTypeArguments { readonly kind: SyntaxKind.ExpressionWithTypeArguments; readonly expression: LeftHandSideExpression; } export interface IFileHandler { loadInclude(sourceFilename: string, filename: string): LoadImportResult; } export interface LoadImportResult { uri: string; source: string; error?: string; } export interface JSDocClassTag extends JSDocTag { readonly kind: SyntaxKind.JSDocClassTag; } export interface JSDocPublicTag extends JSDocTag { readonly kind: SyntaxKind.JSDocPublicTag; } export interface JSDocPrivateTag extends JSDocTag { readonly kind: SyntaxKind.JSDocPrivateTag; } export interface JSDocProtectedTag extends JSDocTag { readonly kind: SyntaxKind.JSDocProtectedTag; } export interface JSDocOverrideTag extends JSDocTag { readonly kind: SyntaxKind.JSDocOverrideTag; } export interface JSDocUnknownTag extends JSDocTag { readonly kind: SyntaxKind.JSDocTag; } export type JSDocNamespaceBody = Identifier; export interface SyntacticTypeNodeBuilderContext { tracker: Required>; enclosingDeclaration: Node | undefined; } export interface LpcConfigSourceFile extends JsonSourceFile { extendedSourceFiles?: string[]; } export interface ParsedLpcConfig { raw: any; options?: CompilerOptions; watchOptions?: WatchOptions; typeAcquisition?: TypeAcquisition; /** * Note that the case of the config path has not yet been normalized, as no files have been imported into the project yet */ extendedConfigPath?: string | string[]; } /** * Branded string for keeping track of when we've turned an ambiguous path * specified like "./blah" to an absolute path to an actual * tsconfig file, e.g. "/root/blah/tsconfig.json" */ export type ResolvedConfigFileName = string & { _isResolvedConfigFileName: never; }; export interface ConditionalTypeNode extends TypeNode, LocalsContainer { readonly kind: SyntaxKind.ConditionalType; readonly checkType: TypeNode; readonly extendsType: TypeNode; readonly trueType: TypeNode; readonly falseType: TypeNode; } export interface ThisTypeNode extends TypeNode { readonly kind: SyntaxKind.ThisType; } export interface JSDocAllType extends JSDocType { readonly kind: SyntaxKind.JSDocAllType; } export interface JSDocUnknownType extends JSDocType { readonly kind: SyntaxKind.JSDocUnknownType; } export interface JSDocOptionalType extends JSDocType { readonly kind: SyntaxKind.JSDocOptionalType; readonly type: TypeNode; } export interface JSDocFunctionType extends JSDocType, SignatureDeclarationBase, LocalsContainer { readonly kind: SyntaxKind.JSDocFunctionType; } export interface TypePredicateNode extends TypeNode { readonly kind: SyntaxKind.TypePredicate; readonly parent: SignatureDeclaration | JSDocTypeExpression; readonly parameterName: Identifier | ThisTypeNode; readonly type?: TypeNode; } export interface NamedTupleMember extends TypeNode, Declaration, JSDocContainer { readonly kind: SyntaxKind.NamedTupleMember; readonly dotDotDotToken?: Token; readonly name: Identifier; readonly questionToken?: Token; readonly type: TypeNode; } export interface TupleType extends GenericType { elementFlags: readonly ElementFlags[]; /** Number of required or variadic elements */ minLength: number; /** Number of initial required or optional elements */ fixedLength: number; /** True if tuple has any rest or variadic elements */ hasRestElement: boolean; combinedFlags: ElementFlags; readonly: boolean; labeledElementDeclarations?: readonly (NamedTupleMember | ParameterDeclaration | undefined)[]; } export interface TupleTypeReference extends TypeReference { target: TupleType; } export type ThisObjectPragmas = { arguments: { name: string; }; range: CommentRange; }; export type BlockLike = SourceFile | Block | CaseOrDefaultClause; export type DeclarationWithTypeParameters = DeclarationWithTypeParameterChildren | JSDocTypedefTag | JSDocCallbackTag | JSDocSignature; export interface ConditionalRoot { node: ConditionalTypeNode; checkType: Type; extendsType: Type; isDistributive: boolean; inferTypeParameters?: TypeParameter[]; outerTypeParameters?: TypeParameter[]; instantiations?: Map; aliasSymbol?: Symbol; aliasTypeArguments?: Type[]; } export interface ConditionalType extends InstantiableType { root: ConditionalRoot; checkType: Type; extendsType: Type; resolvedTrueType?: Type; resolvedFalseType?: Type; } export interface MappingTypeNode extends TypeNode { readonly kind: SyntaxKind.MappingType; readonly keyType: TypeNode; readonly elements: NodeArray; } export interface TupleTypeNode extends TypeNode { readonly kind: SyntaxKind.TupleType; readonly elements: NodeArray; } export interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer { readonly kind: SyntaxKind.InterfaceDeclaration; readonly modifiers?: NodeArray; readonly name: Identifier; readonly typeParameters?: NodeArray; readonly heritageClauses?: NodeArray; readonly members: NodeArray; } export interface JSDocNullableType extends JSDocType { readonly kind: SyntaxKind.JSDocNullableType; readonly type: TypeNode; readonly postfix: boolean; } export interface JSDocNonNullableType extends JSDocType { readonly kind: SyntaxKind.JSDocNonNullableType; readonly type: TypeNode; readonly postfix: boolean; } export type JSDocTypeReferencingNode = JSDocVariadicType | JSDocOptionalType | JSDocNullableType | JSDocNonNullableType; /** Return code used by getEmitOutput function to indicate status of the function */ export declare enum ExitStatus { Success = 0, DiagnosticsPresent_OutputsSkipped = 1, DiagnosticsPresent_OutputsGenerated = 2, InvalidProject_OutputsSkipped = 3, ProjectReferenceCycle_OutputsSkipped = 4 } //# sourceMappingURL=types.d.ts.map