@lpc-lang/core 1.1.2-5.1

package/compiler/types.d.ts

@@ -0,0 +1,3284 @@
+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<string, Symbol>;
+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<TypeNode | TypeParameterDeclaration>;
+    autoGenerate: AutoGenerateInfo | undefined;
+}
+export interface TypeChecker {
+    getTypeOfSymbol(symbol: Symbol): Type;
+    createSymbol(flags: SymbolFlags, name: string, checkFlags?: CheckFlags): TransientSymbol;
+    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<string | number>;
+    /**
+     * True if this type is assignable to `ReadonlyArray<any>`.
+     */
+    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<T>(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<TypeParameterDeclaration> | 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<string> | MapLike<string[]> | 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<WatchDirectoryFlags>;
+    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,
+    QuestionQuestionEqualsToken = 87,
+    CaretEqualsToken = 88,// last assignment
+    Identifier = 89,
+    StringizedIdentifier = 90,
+    IntKeyword = 92,// FIrst Keyword, FirstReserved Word
+    FloatKeyword = 93,
+    StringKeyword = 94,
+    LwObjectKeyword = 95,
+    UndefinedKeyword = 96,
+    AnyKeyword = 97,
+    ClosureKeyword = 98,
+    StructKeyword = 99,
+    CatchKeyword = 100,
+    MixedKeyword = 101,
+    UnknownKeyword = 102,
+    InKeyword = 103,
+    MappingKeyword = 104,
+    VoidKeyword = 105,
+    BreakKeyword = 106,
+    BytesKeyword = 107,
+    BufferKeyword = 108,
+    DoKeyword = 109,
+    ElseKeyword = 110,
+    ForKeyword = 111,
+    ForEachKeyword = 112,
+    CaseKeyword = 113,
+    DefaultKeyword = 114,
+    IfKeyword = 115,
+    ReturnKeyword = 116,
+    SwitchKeyword = 117,
+    WhileKeyword = 118,
+    AsyncKeyword = 119,
+    InheritKeyword = 120,
+    ContinueKeyword = 121,
+    PrivateKeyword = 122,
+    ProtectedKeyword = 123,
+    PublicKeyword = 124,
+    StaticKeyword = 125,
+    VisibleKeyword = 126,
+    NoSaveKeyword = 127,
+    NoShadowKeyword = 128,
+    IntrinsicKeyword = 129,
+    NoMaskKeyword = 130,
+    VarArgsKeyword = 131,
+    DeprecatedKeyword = 132,// LastReservedWord
+    ClassKeyword = 133,
+    StatusKeyword = 134,
+    FalseKeyword = 135,// JSON-only
+    TrueKeyword = 136,// JSON-only
+    NullKeyword = 137,// JSON-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
+    IsKeyword = 142,// use for type predicates only
+    FunctionsKeyword = 143,// inherit modifier
+    VirtualKeyword = 144,// inherit modifier
+    NewKeyword = 145,// LastKeyword and LastToken - everything after this will be processed by the binder
+    QualifiedName = 146,// First Node
+    ComputedPropertyName = 147,
+    TypeParameter = 148,
+    Parameter = 149,
+    IndexSignature = 150,
+    CallSignature = 151,
+    PropertyDeclaration = 152,
+    PropertySignature = 153,
+    MethodDeclaration = 154,
+    InterfaceDeclaration = 155,
+    MethodSignature = 156,
+    UnionType = 157,// First Type Node
+    FunctionType = 158,
+    IntersectionType = 159,
+    RestType = 160,
+    ArrayType = 161,
+    TupleType = 162,
+    TypeLiteral = 163,
+    TypeQuery = 164,
+    ParenthesizedType = 165,
+    TypeReference = 166,
+    TypePredicate = 167,
+    ConditionalType = 168,// Last TYpe Node
+    FunctionDeclaration = 169,
+    ClassDeclaration = 170,
+    ExportSpecifier = 171,
+    ExportDeclaration = 172,
+    MissingDeclaration = 173,
+    PropertyAssignment = 174,
+    ShorthandPropertyAssignment = 175,
+    SourceFile = 176,
+    Bundle = 177,
+    IncludeDirective = 178,
+    DefineDirective = 179,
+    UndefDirective = 180,
+    IfDirective = 181,
+    IfDefDirective = 182,
+    IfNDefDirective = 183,
+    ElseDirective = 184,
+    ElseIfDirective = 185,
+    EndIfDirective = 186,
+    PragmaDirective = 187,
+    JSDocTypeExpression = 188,// First JSDoc Node
+    JSDocNameReference = 189,
+    JSDocMemberName = 190,// C#p
+    JSDocAllType = 191,// The * type
+    JSDocUnknownType = 192,// The ? type
+    JSDocNullableType = 193,
+    JSDocNonNullableType = 194,
+    JSDocOptionalType = 195,
+    JSDocFunctionType = 196,
+    JSDocVariadicType = 197,
+    JSDocNamepathType = 198,// https://jsdoc.app/about-namepaths.html
+    JSDoc = 199,
+    /** @deprecated Use SyntaxKind.JSDoc */
+    JSDocComment = 199,
+    JSDocText = 200,
+    JSDocTypeLiteral = 201,
+    JSDocSignature = 202,
+    JSDocLink = 203,
+    JSDocLinkCode = 204,
+    JSDocLinkPlain = 205,
+    JSDocTag = 206,
+    JSDocAugmentsTag = 207,
+    JSDocImplementsTag = 208,
+    JSDocAuthorTag = 209,
+    JSDocDeprecatedTag = 210,
+    JSDocClassTag = 211,
+    JSDocPublicTag = 212,
+    JSDocPrivateTag = 213,
+    JSDocProtectedTag = 214,
+    JSDocReadonlyTag = 215,
+    JSDocOverrideTag = 216,
+    JSDocCallbackTag = 217,
+    JSDocOverloadTag = 218,
+    JSDocEnumTag = 219,
+    JSDocParameterTag = 220,
+    JSDocReturnTag = 221,
+    JSDocThisTag = 222,
+    JSDocTypeTag = 223,
+    JSDocTemplateTag = 224,
+    JSDocTypedefTag = 225,
+    JSDocSeeTag = 226,
+    JSDocPropertyTag = 227,
+    JSDocVariableTag = 228,
+    JSDocThrowsTag = 229,
+    JSDocSatisfiesTag = 230,
+    JSDocImportTag = 231,// Last JSDoc Node
+    SyntaxList = 232,
+    NotEmittedStatement = 233,
+    PartiallyEmittedExpression = 234,
+    CommaListExpression = 235,
+    Block = 236,
+    VariableDeclaration = 237,
+    VariableDeclarationList = 238,
+    TypeAliasDeclaration = 239,
+    CaseBlock = 240,
+    StructDeclaration = 241,// WAS: ClassDeclaration,
+    VariableStatement = 242,// FirstStatement
+    ForStatement = 243,
+    ForEachStatement = 244,
+    DoWhileStatement = 245,
+    WhileStatement = 246,
+    ExpressionStatement = 247,
+    ReturnStatement = 248,
+    LabeledStatement = 249,
+    BreakStatement = 250,
+    ContinueStatement = 251,
+    InheritDeclaration = 252,
+    IfStatement = 253,
+    EmptyStatement = 254,
+    CatchStatement = 255,
+    SwitchStatement = 256,// LastStatement
+    LiteralType = 257,
+    StructType = 258,
+    InferType = 259,
+    ThisType = 260,
+    IndexedAccessType = 261,
+    NamedTupleMember = 262,
+    TypeOperator = 263,
+    MappedType = 264,
+    ArrayBindingPattern = 265,
+    BindingElement = 266,
+    ConditionalExpression = 267,
+    CatchExpression = 268,
+    BinaryExpression = 269,
+    FunctionExpression = 270,
+    ArrowFunction = 271,
+    CallExpression = 272,
+    CloneObjectExpression = 273,
+    ClassExpression = 274,
+    SyntheticExpression = 275,
+    NewExpression = 276,
+    NewStructExpression = 277,
+    EvaluateExpression = 278,
+    TypeAssertionExpression = 279,
+    ExpressionWithTypeArguments = 280,
+    ElementAccessExpression = 281,
+    RangeExpression = 282,
+    InlineClosureExpression = 283,
+    LambdaIdentifierExpression = 284,
+    LambdaOperatorExpression = 285,
+    PropertyAccessExpression = 286,
+    SuperAccessExpression = 287,
+    PostfixUnaryExpression = 288,
+    ParenthesizedExpression = 289,
+    ArrayLiteralExpression = 290,
+    MappingLiteralExpression = 291,
+    MappingEntryExpression = 292,
+    ObjectLiteralExpression = 293,
+    SpreadElement = 294,
+    ByRefElement = 295,
+    CastExpression = 296,
+    OmittedExpression = 297,
+    PrefixUnaryExpression = 298,
+    CaseClause = 299,
+    HeritageClause = 300,
+    DefaultClause = 301,
+    Count = 302,
+    FirstReservedWord = 92,
+    LastReservedWord = 132,
+    FirstKeyword = 92,
+    LastKeyword = 145,
+    FirstToken = 0,
+    LastToken = 145,
+    FirstStatement = 242,
+    LastStatement = 256,
+    FirstAssignment = 74,
+    LastAssignment = 88,
+    SuperKeyword = 71,
+    FirstTypeNode = 157,
+    LastTypeNode = 168,
+    FirstNode = 146,
+    FirstFutureReservedWord = 92,
+    LastFutureReservedWord = 145,
+    FirstJSDocNode = 188,
+    LastJSDocNode = 231,
+    FirstLiteralToken = 11,
+    LastLiteralToken = 16,
+    FirstJSDocTagNode = 188,
+    LastJSDocTagNode = 231,
+    FirstTriviaToken = 2,
+    LastTriviaToken = 8,
+    FirstBinaryOperator = 29,
+    LastBinaryOperator = 88,
+    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<T> 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
+    JSDoc = 16777216,// If has '@deprecated' JSDoc tag
+    ReachabilityCheckFlags = 1536,
+    ReachabilityAndEmitFlags = 1536,
+    ContextFlags = 34332768,
+    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.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.LiteralType | SyntaxKind.ThisType | SyntaxKind.TypePredicate | SyntaxKind.MappedType | SyntaxKind.TypeLiteral | SyntaxKind.ParenthesizedType | SyntaxKind.TypeReference | SyntaxKind.ExpressionWithTypeArguments | SyntaxKind.FunctionType | SyntaxKind.ConditionalType | SyntaxKind.IntersectionType | 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;
+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<string, Type>;
+    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<T extends Node>(elements?: readonly T[], hasTrailingComma?: boolean): NodeArray<T>;
+    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<SyntaxKind.Unknown>;
+    createIdentifier(text: string): Identifier;
+    createLiteralLikeNode(kind: LiteralToken["kind"], text: string): LiteralToken;
+    createEmptyStatement(): EmptyStatement;
+    createModifier<T extends ModifierSyntaxKind>(kind: T): ModifierToken<T>;
+    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<Identifier>): PragmaDirective;
+    createDefineDirective(name: string | Identifier | TypeNode, args: NodeArray<ParameterDeclaration>, 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<TKind extends KeywordTypeSyntaxKind>(kind: TKind): KeywordTypeNode<TKind>;
+    createTypeReferenceNode(typeName: string | EntityName, typeArguments?: readonly TypeNode[]): TypeReferenceNode;
+    updateTypeReferenceNode(node: TypeReferenceNode, typeName: EntityName, typeArguments: NodeArray<TypeNode> | undefined): TypeReferenceNode;
+    createUnionTypeNode(types: readonly TypeNode[]): UnionTypeNode;
+    createIntersectionTypeNode(types: readonly TypeNode[]): IntersectionTypeNode;
+    createArrayTypeNode(elementType: TypeNode): ArrayTypeNode;
+    createParenthesizedType(type: TypeNode): ParenthesizedTypeNode;
+    createLiteralTypeNode(literal: LiteralTypeNode["literal"]): LiteralTypeNode;
+    createTypeLiteralNode(members: readonly TypeElement[] | undefined): TypeLiteralNode;
+    createStructTypeNode(name: Identifier): 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<Statement>, 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): 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<Expression>): 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<VariableDeclaration>): 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<JSDocComment> | undefined, tags?: readonly JSDocTag[] | undefined): JSDoc;
+    createJSDocParameterTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocParameterTag;
+    createJSDocReturnTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocReturnTag;
+    createJSDocOptionalType(type: TypeNode): JSDocOptionalType;
+    createJSDocTypeTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): 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<JSDocComment>): JSDocClassTag;
+    createJSDocPublicTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPublicTag;
+    createJSDocPrivateTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocPrivateTag;
+    createJSDocProtectedTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocProtectedTag;
+    createJSDocDeprecatedTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocDeprecatedTag;
+    createJSDocOverrideTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocOverrideTag;
+    createJSDocUnknownTag(tagName: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocUnknownTag;
+    createJSDocPropertyTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocPropertyTag;
+    createJSDocVariableTag(tagName: Identifier | undefined, name: EntityName, isBracketed: boolean, typeExpression?: JSDocTypeExpression, isNameFirst?: boolean, comment?: string | NodeArray<JSDocComment>): JSDocVariableTag;
+    createJSDocTypeLiteral(propertyTags?: readonly JSDocPropertyLikeTag[], isArrayType?: boolean): JSDocTypeLiteral;
+    createJSDocSeeTag(tagName: Identifier | undefined, name: JSDocNameReference | undefined, comment?: string | NodeArray<JSDocComment>): JSDocSeeTag;
+    createJSDocAuthorTag(tagName: Identifier | undefined, comment?: string | NodeArray<JSDocComment>): JSDocAuthorTag;
+    createJSDocThrowsTag(tagName: Identifier, typeExpression: JSDocTypeExpression | undefined, comment?: string | NodeArray<JSDocComment>): JSDocThrowsTag;
+    createJSDocImplementsTag(tagName: Identifier | undefined, className: JSDocImplementsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocImplementsTag;
+    createJSDocTypedefTag(tagName: Identifier | undefined, typeExpression?: JSDocTypeExpression | JSDocTypeLiteral, fullName?: Identifier, comment?: string | NodeArray<JSDocComment>): JSDocTypedefTag;
+    createJSDocAugmentsTag(tagName: Identifier | undefined, className: JSDocAugmentsTag["class"], comment?: string | NodeArray<JSDocComment>): JSDocAugmentsTag;
+    createJSDocSatisfiesTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): JSDocSatisfiesTag;
+    createJSDocThisTag(tagName: Identifier | undefined, typeExpression: JSDocTypeExpression, comment?: string | NodeArray<JSDocComment>): 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<JSDocComment>): JSDocCallbackTag;
+    createJSDocOverloadTag(tagName: Identifier | undefined, typeExpression: JSDocSignature, comment?: string | NodeArray<JSDocComment>): JSDocOverloadTag;
+    createJSDocTemplateTag(tagName: Identifier | undefined, constraint: JSDocTypeExpression | undefined, typeParameters: readonly TypeParameterDeclaration[], comment?: string | NodeArray<JSDocComment>): 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<string>;
+    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<string[]>;
+    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<T extends Node> extends ReadonlyArray<T>, ReadonlyTextRange {
+    readonly hasTrailingComma: boolean;
+    readonly isComplete?: boolean;
+}
+export interface Token<TKind extends SyntaxKind> extends Node {
+    readonly kind: TKind;
+}
+export type EndOfFileToken = Token<SyntaxKind.EndOfFileToken> & 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 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.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<TKind extends KeywordSyntaxKind> extends Token<TKind> {
+}
+export interface KeywordTypeNode<TKind extends KeywordTypeSyntaxKind = KeywordTypeSyntaxKind> extends KeywordToken<TKind>, TypeNode {
+    readonly kind: TKind;
+}
+export type CaseKeyword = KeywordToken<SyntaxKind.CaseKeyword>;
+export type RefToken = KeywordToken<SyntaxKind.RefKeyword>;
+export interface ModifierToken<TKind extends ModifierSyntaxKind> extends KeywordToken<TKind> {
+}
+export type PrivateKeyword = ModifierToken<SyntaxKind.PrivateKeyword>;
+export type ProtectedKeyword = ModifierToken<SyntaxKind.ProtectedKeyword>;
+export type PublicKeyword = ModifierToken<SyntaxKind.PublicKeyword>;
+export type StaticKeyword = ModifierToken<SyntaxKind.StaticKeyword>;
+export type VisibleKeyword = ModifierToken<SyntaxKind.VisibleKeyword>;
+export type NoSaveKeyword = ModifierToken<SyntaxKind.NoSaveKeyword>;
+export type NoShadowKeyword = ModifierToken<SyntaxKind.NoShadowKeyword>;
+export type NoMaskKeyword = ModifierToken<SyntaxKind.NoMaskKeyword>;
+export type VarArgsKeyword = ModifierToken<SyntaxKind.VarArgsKeyword>;
+export type DeprecatedKeyword = ModifierToken<SyntaxKind.DeprecatedKeyword>;
+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;
+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;
+export type AssignmentOperator = SyntaxKind.EqualsToken | CompoundAssignmentOperator;
+export type AssignmentOperatorOrHigher = LogicalOperatorOrHigher | AssignmentOperator;
+export type BinaryOperator = AssignmentOperatorOrHigher | SyntaxKind.CommaToken;
+export type BinaryOperatorToken = Token<BinaryOperator>;
+export type LogicalOrCoalescingAssignmentOperator = SyntaxKind.BarBarEqualsToken;
+export type LambdaOperatorToken = Token<PunctuationSyntaxKind>;
+export interface PunctuationToken<TKind extends PunctuationSyntaxKind> extends Token<TKind> {
+}
+export type DotToken = PunctuationToken<SyntaxKind.DotToken>;
+export type AmpersandToken = PunctuationToken<SyntaxKind.AmpersandToken>;
+export type DotDotDotToken = PunctuationToken<SyntaxKind.DotDotDotToken>;
+export type QuestionToken = PunctuationToken<SyntaxKind.QuestionToken>;
+export type ExclamationToken = PunctuationToken<SyntaxKind.ExclamationToken>;
+export type DoubleExclamationToken = PunctuationToken<SyntaxKind.DoubleExclamationToken>;
+export type ColonToken = PunctuationToken<SyntaxKind.ColonToken>;
+export type EqualsToken = PunctuationToken<SyntaxKind.EqualsToken>;
+export type BarBarEqualsToken = PunctuationToken<SyntaxKind.BarBarEqualsToken>;
+export type AsteriskToken = PunctuationToken<SyntaxKind.AsteriskToken>;
+export type EqualsGreaterThanToken = PunctuationToken<SyntaxKind.EqualsGreaterThanToken>;
+export type MinusGreaterThanToken = PunctuationToken<SyntaxKind.MinusGreaterThanToken>;
+export type PlusToken = PunctuationToken<SyntaxKind.PlusToken>;
+export type MinusToken = PunctuationToken<SyntaxKind.MinusToken>;
+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<InheritDeclaration>;
+}
+export interface SourceFile extends Declaration, LocalsContainer, HasHeritageContainer, SourceFileBase {
+    readonly kind: SyntaxKind.SourceFile;
+    readonly statements: NodeArray<Statement>;
+    readonly endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
+    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<string, string>;
+    /** 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<Node, string>;
+}
+export interface JsonSourceFile extends SourceFile {
+    readonly statements: NodeArray<JsonObjectExpressionStatement>;
+}
+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 | 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<TypeNode>;
+}
+export interface IntersectionTypeNode extends TypeNode {
+    readonly kind: SyntaxKind.IntersectionType;
+    readonly types: NodeArray<TypeNode>;
+}
+export interface ArrayTypeNode extends TypeNode {
+    readonly kind: SyntaxKind.ArrayType;
+    readonly elementType: TypeNode;
+}
+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 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<JSDocComment>;
+}
+export interface JSDoc extends Node {
+    readonly kind: SyntaxKind.JSDoc;
+    readonly parent: HasJSDoc;
+    readonly tags?: NodeArray<JSDocTag>;
+    readonly comment?: string | NodeArray<JSDocComment>;
+}
+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<Statement>;
+}
+export interface CatchStatement extends Statement, LocalsContainer {
+    readonly kind: SyntaxKind.CatchStatement;
+    readonly parent: Block;
+    readonly expression?: Expression;
+    readonly block: Block;
+}
+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<SyntaxKind.EqualsToken>;
+    readonly initializer?: Expression;
+}
+export interface VariableDeclarationList extends Node {
+    readonly kind: SyntaxKind.VariableDeclarationList;
+    readonly parent: VariableStatement | ForStatement | ForEachStatement;
+    readonly declarations: NodeArray<VariableDeclaration>;
+}
+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<Modifier>;
+    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<Modifier>;
+    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<TypeParameterDeclaration> | undefined;
+    readonly parameters: NodeArray<ParameterDeclaration>;
+    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<Modifier>;
+    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<Modifier>;
+    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<Modifier>;
+    readonly name?: Identifier;
+    readonly body?: FunctionBody;
+}
+export interface CallExpression extends LeftHandSideExpression, Declaration {
+    readonly kind: SyntaxKind.CallExpression;
+    readonly expression: LeftHandSideExpression;
+    readonly typeArguments?: NodeArray<TypeNode>;
+    readonly arguments: NodeArray<Expression>;
+}
+export interface CloneObjectExpression extends PrimaryExpression, Declaration, LeftHandSideExpression {
+    readonly kind: SyntaxKind.CloneObjectExpression;
+    readonly expression: LeftHandSideExpression;
+    readonly arguments?: NodeArray<Expression>;
+}
+export interface MappingLiteralExpression extends PrimaryExpression {
+    readonly kind: SyntaxKind.MappingLiteralExpression;
+    readonly elements: NodeArray<MappingEntryExpression | OmittedExpression>;
+    readonly initializer?: Expression;
+}
+export interface MappingEntryExpression extends PrimaryExpression {
+    readonly kind: SyntaxKind.MappingEntryExpression;
+    readonly name: Expression;
+    readonly elements: NodeArray<Expression>;
+}
+export interface InlineClosureExpression extends PrimaryExpression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer {
+    readonly kind: SyntaxKind.InlineClosureExpression;
+    readonly modifiers?: NodeArray<Modifier>;
+    readonly body: ConciseBody;
+    readonly name: never;
+    readonly arguments?: NodeArray<Expression>;
+}
+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<Modifier>;
+    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<Statement>;
+    readonly caseBlock: CaseBlock;
+    possiblyExhaustive?: boolean;
+}
+export interface CaseBlock extends Node, LocalsContainer {
+    readonly kind: SyntaxKind.CaseBlock;
+    readonly parent: SwitchStatement;
+    readonly clauses: NodeArray<CaseOrDefaultClause>;
+}
+export interface CaseClause extends Node, JSDocContainer {
+    readonly kind: SyntaxKind.CaseClause;
+    readonly parent: CaseBlock;
+    readonly expression: Expression;
+    readonly statements: NodeArray<Statement>;
+}
+export interface DefaultClause extends Node {
+    readonly kind: SyntaxKind.DefaultClause;
+    readonly parent: CaseBlock;
+    readonly statements: NodeArray<Statement>;
+}
+export type CaseOrDefaultClause = CaseClause | DefaultClause;
+export interface PropertyAccessExpression extends MemberExpression, NamedDeclaration, JSDocContainer, FlowContainer {
+    readonly kind: SyntaxKind.PropertyAccessExpression;
+    readonly expression: LeftHandSideExpression;
+    readonly name: MemberName;
+    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<TypeParameterDeclaration>;
+    readonly modifiers?: NodeArray<Modifier>;
+    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<AssignmentOperator>;
+export interface AssignmentExpression<TOperator extends AssignmentOperatorToken> 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<Expression>;
+}
+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: ObjectLiteralExpression;
+    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<T extends ObjectLiteralElement> extends PrimaryExpression, Declaration {
+    readonly properties: NodeArray<T>;
+}
+export interface ObjectLiteralExpression extends ObjectLiteralExpressionBase<ObjectLiteralElementLike>, 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<Expression | ObjectLiteralElementLike>;
+}
+export interface EvaluateExpression extends PrimaryExpression {
+    readonly kind: SyntaxKind.EvaluateExpression;
+    readonly expression: Expression;
+    readonly arguments: NodeArray<Expression>;
+}
+export interface NewExpression extends PrimaryExpression, Declaration {
+    readonly kind: SyntaxKind.NewExpression;
+    readonly expression?: LeftHandSideExpression | TypeNode | undefined;
+    readonly typeArguments?: NodeArray<TypeNode>;
+    readonly arguments?: NodeArray<Expression>;
+}
+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<TypeElement>;
+}
+export type ObjectTypeDeclaration = TypeLiteralNode;
+export interface IndexSignatureDeclaration extends SignatureDeclarationBase, ClassElement, TypeElement, LocalsContainer {
+    readonly kind: SyntaxKind.IndexSignature;
+    readonly parent: ObjectTypeDeclaration;
+    readonly modifiers?: NodeArray<Modifier>;
+    readonly type: TypeNode;
+}
+export interface EvaluatorResult<T extends string | number | undefined = string | number | undefined> {
+    value: T;
+    isSyntacticallyString: boolean;
+    resolvedOtherFiles: boolean;
+    hasExternalReferences: boolean;
+}
+export interface JSDocTemplateTag extends JSDocTag {
+    readonly kind: SyntaxKind.JSDocTemplateTag;
+    readonly constraint: JSDocTypeExpression | undefined;
+    readonly typeParameters: NodeArray<TypeParameterDeclaration>;
+}
+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<Modifier>;
+    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 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<ArrayBindingElement>;
+}
+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[];
+    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[];
+    getConfigDefines(): ReadonlyMap<string, string>;
+    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<T> 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<x>.b<y>` 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<TypeElement>;
+}
+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<T extends Node>(format: ListFormat, list: NodeArray<T>, 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<Expression>;
+}
+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<Expression>;
+}
+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<TypeNode>;
+}
+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 extends Node | undefined> = T | readonly Node[];
+/**
+ * A function that accepts and possibly transforms a node.
+ */
+export type Visitor<TIn extends Node = Node, TOut extends Node | undefined = TIn | undefined> = (node: TIn) => VisitResult<TOut>;
+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<Node>`, 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 {
+    <TIn extends Node, TInArray extends NodeArray<TIn> | undefined, TOut extends Node>(nodes: TInArray, visitor: Visitor<TIn, Node | undefined>, test: (node: Node) => node is TOut, start?: number, count?: number): NodeArray<TOut> | (TInArray & undefined);
+    <TIn extends Node, TInArray extends NodeArray<TIn> | undefined>(nodes: TInArray, visitor: Visitor<TIn, Node | undefined>, test?: (node: Node) => boolean, start?: number, count?: number): NodeArray<Node> | (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<T extends Node> {
+    /** 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<T extends Node> = (context: TransformationContext) => Transformer<T>;
+/**
+ * A function that transforms a node.
+ */
+export type Transformer<T extends Node> = (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<Modifier>;
+    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<Modifier>;
+    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 {
+    <TIn extends Node | undefined, TVisited extends Node | undefined, TOut extends Node>(node: TIn, visitor: Visitor<NonNullable<TIn>, TVisited>, test: (node: Node) => node is TOut, lift?: (node: readonly Node[]) => Node): TOut | (TIn & undefined) | (TVisited & undefined);
+    <TIn extends Node | undefined, TVisited extends Node | undefined>(node: TIn, visitor: Visitor<NonNullable<TIn>, 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<Modifier> | 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<Modifier>;
+    readonly name: PropertyName;
+}
+export interface ArrowFunction extends Expression, FunctionLikeDeclarationBase, JSDocContainer, LocalsContainer, FlowContainer {
+    readonly kind: SyntaxKind.ArrowFunction;
+    readonly modifiers?: NodeArray<Modifier>;
+    readonly equalsGreaterThanToken: EqualsGreaterThanToken;
+    readonly body: ConciseBody;
+    readonly name: never;
+}
+export interface ClassExpression extends ClassLikeDeclarationBase, PrimaryExpression {
+    readonly kind: SyntaxKind.ClassExpression;
+    readonly modifiers?: NodeArray<Modifier>;
+}
+export interface PreprocessorDirective extends Statement {
+    kind: DirectiveSyntaxKind;
+}
+export interface PragmaDirective extends PreprocessorDirective {
+    kind: SyntaxKind.PragmaDirective;
+    expression: NodeArray<Identifier>;
+}
+export interface IncludeDirective extends PreprocessorDirective, SourceFileBase {
+    kind: SyntaxKind.IncludeDirective;
+    content: NodeArray<StringLiteral>;
+    readonly fileName: string;
+    readonly localFirst: boolean;
+    readonly statements: NodeArray<Statement>;
+    readonly endOfFileToken: Token<SyntaxKind.EndOfFileToken>;
+    readonly text: string;
+    inactiveCodeRanges?: readonly TextRange[];
+}
+export interface DefineDirective extends PreprocessorDirective, Declaration {
+    kind: SyntaxKind.DefineDirective;
+    name: Identifier;
+    arguments?: NodeArray<ParameterDeclaration>;
+    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;
+    includeDirPos?: number;
+    includeDirEnd?: number;
+    includeFilename?: string;
+    disabled?: boolean;
+    /** get the sourcetext that contains the macro definition range */
+    getText(): string;
+    range: TextRange;
+    arguments?: NodeArray<ParameterDeclaration>;
+    argsIn?: MapLike<MacroParameter>;
+    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<TypeParameterDeclaration>;
+    readonly members: NodeArray<ClassElement>;
+}
+export interface ClassDeclaration extends ClassLikeDeclarationBase, DeclarationStatement {
+    readonly kind: SyntaxKind.ClassDeclaration;
+    readonly modifiers?: NodeArray<Modifier>;
+    /** 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<ModifierLike>;
+    readonly name: Identifier;
+    readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
+    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<Pick<SymbolTracker, "reportInferenceFallback">>;
+    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<SyntaxKind.DotDotDotToken>;
+    readonly name: Identifier;
+    readonly questionToken?: Token<SyntaxKind.QuestionToken>;
+    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<string, Type>;
+    aliasSymbol?: Symbol;
+    aliasTypeArguments?: Type[];
+}
+export interface ConditionalType extends InstantiableType {
+    root: ConditionalRoot;
+    checkType: Type;
+    extendsType: Type;
+    resolvedTrueType?: Type;
+    resolvedFalseType?: Type;
+}
+export interface TupleTypeNode extends TypeNode {
+    readonly kind: SyntaxKind.TupleType;
+    readonly elements: NodeArray<TypeNode | NamedTupleMember>;
+}
+export interface InterfaceDeclaration extends DeclarationStatement, JSDocContainer {
+    readonly kind: SyntaxKind.InterfaceDeclaration;
+    readonly modifiers?: NodeArray<ModifierLike>;
+    readonly name: Identifier;
+    readonly typeParameters?: NodeArray<TypeParameterDeclaration>;
+    readonly heritageClauses?: NodeArray<HeritageClause>;
+    readonly members: NodeArray<TypeElement>;
+}
+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